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



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

/* -----------------------------------------------------------------------------
 * 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_AutoConstantEntry swig_types[3]
#define SWIGTYPE_p_AutoConstantIterator swig_types[4]
#define SWIGTYPE_p_AutoConstantList swig_types[5]
#define SWIGTYPE_p_BatchInstanceIterator swig_types[6]
#define SWIGTYPE_p_BatchInstanceMap swig_types[7]
#define SWIGTYPE_p_BindingIndexMap swig_types[8]
#define SWIGTYPE_p_BoneAssignmentIterator swig_types[9]
#define SWIGTYPE_p_BoneBlendMask swig_types[10]
#define SWIGTYPE_p_BoneHandleMap swig_types[11]
#define SWIGTYPE_p_BoneIterator swig_types[12]
#define SWIGTYPE_p_BoneList swig_types[13]
#define SWIGTYPE_p_BoundSufaceList swig_types[14]
#define SWIGTYPE_p_Box swig_types[15]
#define SWIGTYPE_p_CameraIterator swig_types[16]
#define SWIGTYPE_p_CameraList swig_types[17]
#define SWIGTYPE_p_ChildContainerIterator swig_types[18]
#define SWIGTYPE_p_ChildContainerMap swig_types[19]
#define SWIGTYPE_p_ChildIterator swig_types[20]
#define SWIGTYPE_p_ChildMap swig_types[21]
#define SWIGTYPE_p_ChildNodeIterator swig_types[22]
#define SWIGTYPE_p_ChildNodeMap swig_types[23]
#define SWIGTYPE_p_ChildObjectList swig_types[24]
#define SWIGTYPE_p_ChildObjectListIterator swig_types[25]
#define SWIGTYPE_p_CodePoint swig_types[26]
#define SWIGTYPE_p_CodePointRange swig_types[27]
#define SWIGTYPE_p_CodePointRangeList swig_types[28]
#define SWIGTYPE_p_CodecDataPtr swig_types[29]
#define SWIGTYPE_p_CodecIterator swig_types[30]
#define SWIGTYPE_p_CompiledState swig_types[31]
#define SWIGTYPE_p_ConstChildNodeIterator swig_types[32]
#define SWIGTYPE_p_ConstNormalsIterator swig_types[33]
#define SWIGTYPE_p_ConstObjectIterator swig_types[34]
#define SWIGTYPE_p_ConstPoseIterator swig_types[35]
#define SWIGTYPE_p_ConstPoseRefIterator swig_types[36]
#define SWIGTYPE_p_ConstPriorityMapIterator swig_types[37]
#define SWIGTYPE_p_ConstQueueGroupIterator swig_types[38]
#define SWIGTYPE_p_ConstTerrainIterator swig_types[39]
#define SWIGTYPE_p_ConstTextureUnitStateIterator swig_types[40]
#define SWIGTYPE_p_ConstVertexOffsetIterator swig_types[41]
#define SWIGTYPE_p_ContentCollectionFactoryMap swig_types[42]
#define SWIGTYPE_p_ContentCollectionList swig_types[43]
#define SWIGTYPE_p_ContentFactoryMap swig_types[44]
#define SWIGTYPE_p_ContentList swig_types[45]
#define SWIGTYPE_p_CornerEnum swig_types[46]
#define SWIGTYPE_p_DecodeResult swig_types[47]
#define SWIGTYPE_p_Edge swig_types[48]
#define SWIGTYPE_p_EdgeGroupList swig_types[49]
#define SWIGTYPE_p_EdgeList swig_types[50]
#define SWIGTYPE_p_EdgeMap swig_types[51]
#define SWIGTYPE_p_EffectMap swig_types[52]
#define SWIGTYPE_p_ElementList swig_types[53]
#define SWIGTYPE_p_ElementMap swig_types[54]
#define SWIGTYPE_p_EntitySet swig_types[55]
#define SWIGTYPE_p_ErrorList swig_types[56]
#define SWIGTYPE_p_ErrorPtr swig_types[57]
#define SWIGTYPE_p_FILE swig_types[58]
#define SWIGTYPE_p_FactoryMap swig_types[59]
#define SWIGTYPE_p_GPUDeviceNameRule swig_types[60]
#define SWIGTYPE_p_GPUDeviceNameRuleIterator swig_types[61]
#define SWIGTYPE_p_GPUDeviceNameRuleList swig_types[62]
#define SWIGTYPE_p_GPUVendorRule swig_types[63]
#define SWIGTYPE_p_GPUVendorRuleIterator swig_types[64]
#define SWIGTYPE_p_GPUVendorRuleList swig_types[65]
#define SWIGTYPE_p_GpuSharedParamUsageList swig_types[66]
#define SWIGTYPE_p_HardwareAnimationDataList swig_types[67]
#define SWIGTYPE_p_IdMap swig_types[68]
#define SWIGTYPE_p_IlluminationPassIterator swig_types[69]
#define SWIGTYPE_p_ImportData swig_types[70]
#define SWIGTYPE_p_IndexMap swig_types[71]
#define SWIGTYPE_p_IndexRemapList swig_types[72]
#define SWIGTYPE_p_InstanceBatchIterator swig_types[73]
#define SWIGTYPE_p_InstanceBatchMapIterator swig_types[74]
#define SWIGTYPE_p_InstanceIterator swig_types[75]
#define SWIGTYPE_p_InstancedEntityVec swig_types[76]
#define SWIGTYPE_p_Instances swig_types[77]
#define SWIGTYPE_p_Intp swig_types[78]
#define SWIGTYPE_p_LODFaceList swig_types[79]
#define SWIGTYPE_p_LayerInstanceList swig_types[80]
#define SWIGTYPE_p_LinkedSkeletonAnimSourceIterator swig_types[81]
#define SWIGTYPE_p_LinkedSkeletonAnimSourceList swig_types[82]
#define SWIGTYPE_p_LocationList swig_types[83]
#define SWIGTYPE_p_LodLevelList swig_types[84]
#define SWIGTYPE_p_LodValueIterator swig_types[85]
#define SWIGTYPE_p_LodValueList swig_types[86]
#define SWIGTYPE_p_MeshLodUsageList swig_types[87]
#define SWIGTYPE_p_MetaDataIterator swig_types[88]
#define SWIGTYPE_p_MetaDataList swig_types[89]
#define SWIGTYPE_p_Microcode swig_types[90]
#define SWIGTYPE_p_MicrocodeMap swig_types[91]
#define SWIGTYPE_p_MovableObjectFactoryIterator swig_types[92]
#define SWIGTYPE_p_MovableObjectIterator swig_types[93]
#define SWIGTYPE_p_NodeIterator swig_types[94]
#define SWIGTYPE_p_NodeList swig_types[95]
#define SWIGTYPE_p_NodeTrackIterator swig_types[96]
#define SWIGTYPE_p_NodeTrackList swig_types[97]
#define SWIGTYPE_p_NormalsIterator swig_types[98]
#define SWIGTYPE_p_NormalsMap swig_types[99]
#define SWIGTYPE_p_NumericTrackIterator swig_types[100]
#define SWIGTYPE_p_NumericTrackList swig_types[101]
#define SWIGTYPE_p_ObjectIterator swig_types[102]
#define SWIGTYPE_p_ObjectMap swig_types[103]
#define SWIGTYPE_p_Ogre__AbstractNode swig_types[104]
#define SWIGTYPE_p_Ogre__AlignedMemory swig_types[105]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t_t swig_types[106]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t_t swig_types[107]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t_t swig_types[108]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t_t swig_types[109]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t_t swig_types[110]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t_t swig_types[111]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t_t swig_types[112]
#define SWIGTYPE_p_Ogre__AllocatedObjectT_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t_t swig_types[113]
#define SWIGTYPE_p_Ogre__Angle swig_types[114]
#define SWIGTYPE_p_Ogre__AnimableObject swig_types[115]
#define SWIGTYPE_p_Ogre__AnimableValue swig_types[116]
#define SWIGTYPE_p_Ogre__Animation swig_types[117]
#define SWIGTYPE_p_Ogre__AnimationContainer swig_types[118]
#define SWIGTYPE_p_Ogre__AnimationControllerFunction swig_types[119]
#define SWIGTYPE_p_Ogre__AnimationState swig_types[120]
#define SWIGTYPE_p_Ogre__AnimationStateControllerValue swig_types[121]
#define SWIGTYPE_p_Ogre__AnimationStateIterator swig_types[122]
#define SWIGTYPE_p_Ogre__AnimationStateSet swig_types[123]
#define SWIGTYPE_p_Ogre__AnimationTrack swig_types[124]
#define SWIGTYPE_p_Ogre__AnimationTrack__Listener swig_types[125]
#define SWIGTYPE_p_Ogre__Any swig_types[126]
#define SWIGTYPE_p_Ogre__AnyNumeric swig_types[127]
#define SWIGTYPE_p_Ogre__AnyVALUE swig_types[128]
#define SWIGTYPE_p_Ogre__Archive swig_types[129]
#define SWIGTYPE_p_Ogre__ArchiveFactory swig_types[130]
#define SWIGTYPE_p_Ogre__ArchiveManager swig_types[131]
#define SWIGTYPE_p_Ogre__AtomAbstractNode swig_types[132]
#define SWIGTYPE_p_Ogre__AutoParamDataSource swig_types[133]
#define SWIGTYPE_p_Ogre__AxisAlignedBox swig_types[134]
#define SWIGTYPE_p_Ogre__AxisAlignedBoxSceneQuery swig_types[135]
#define SWIGTYPE_p_Ogre__BackgroundProcessResult swig_types[136]
#define SWIGTYPE_p_Ogre__BaseInstanceBatchVTF swig_types[137]
#define SWIGTYPE_p_Ogre__Billboard swig_types[138]
#define SWIGTYPE_p_Ogre__BillboardChain swig_types[139]
#define SWIGTYPE_p_Ogre__BillboardChainFactory swig_types[140]
#define SWIGTYPE_p_Ogre__BillboardChain__Element swig_types[141]
#define SWIGTYPE_p_Ogre__BillboardParticleRenderer swig_types[142]
#define SWIGTYPE_p_Ogre__BillboardParticleRendererFactory swig_types[143]
#define SWIGTYPE_p_Ogre__BillboardSet swig_types[144]
#define SWIGTYPE_p_Ogre__BillboardSetFactory swig_types[145]
#define SWIGTYPE_p_Ogre__Bitwise swig_types[146]
#define SWIGTYPE_p_Ogre__Bone swig_types[147]
#define SWIGTYPE_p_Ogre__BorderPanelOverlayElement swig_types[148]
#define SWIGTYPE_p_Ogre__BorderPanelOverlayElementFactory swig_types[149]
#define SWIGTYPE_p_Ogre__BorderRenderable swig_types[150]
#define SWIGTYPE_p_Ogre__Box swig_types[151]
#define SWIGTYPE_p_Ogre__BuiltinScriptTranslatorManager swig_types[152]
#define SWIGTYPE_p_Ogre__Camera swig_types[153]
#define SWIGTYPE_p_Ogre__Camera__Listener swig_types[154]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_ANIMATION_t swig_types[155]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GENERAL_t swig_types[156]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_t swig_types[157]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RENDERSYS_t swig_types[158]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_RESOURCE_t swig_types[159]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_CONTROL_t swig_types[160]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCENE_OBJECTS_t swig_types[161]
#define SWIGTYPE_p_Ogre__CategorisedAllocPolicyT_Ogre__MEMCATEGORY_SCRIPTING_t swig_types[162]
#define SWIGTYPE_p_Ogre__Codec swig_types[163]
#define SWIGTYPE_p_Ogre__ColourValue swig_types[164]
#define SWIGTYPE_p_Ogre__CompositionPass swig_types[165]
#define SWIGTYPE_p_Ogre__CompositionPassTranslator swig_types[166]
#define SWIGTYPE_p_Ogre__CompositionPass__InputTex swig_types[167]
#define SWIGTYPE_p_Ogre__CompositionTargetPass swig_types[168]
#define SWIGTYPE_p_Ogre__CompositionTargetPassTranslator swig_types[169]
#define SWIGTYPE_p_Ogre__CompositionTechnique swig_types[170]
#define SWIGTYPE_p_Ogre__CompositionTechniqueTranslator swig_types[171]
#define SWIGTYPE_p_Ogre__CompositionTechnique__TextureDefinition swig_types[172]
#define SWIGTYPE_p_Ogre__Compositor swig_types[173]
#define SWIGTYPE_p_Ogre__CompositorChain swig_types[174]
#define SWIGTYPE_p_Ogre__CompositorInstance swig_types[175]
#define SWIGTYPE_p_Ogre__CompositorInstance__Listener swig_types[176]
#define SWIGTYPE_p_Ogre__CompositorInstance__RenderSystemOperation swig_types[177]
#define SWIGTYPE_p_Ogre__CompositorInstance__TargetOperation swig_types[178]
#define SWIGTYPE_p_Ogre__CompositorLogic swig_types[179]
#define SWIGTYPE_p_Ogre__CompositorManager swig_types[180]
#define SWIGTYPE_p_Ogre__CompositorPtr swig_types[181]
#define SWIGTYPE_p_Ogre__CompositorTranslator swig_types[182]
#define SWIGTYPE_p_Ogre__ConcreteNode swig_types[183]
#define SWIGTYPE_p_Ogre__ConfigFile swig_types[184]
#define SWIGTYPE_p_Ogre__ConstAnimationStateIterator swig_types[185]
#define SWIGTYPE_p_Ogre__ConstEnabledAnimationStateIterator swig_types[186]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__RenderQueueGroupMap_t swig_types[187]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[188]
#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[189]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[190]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_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_t swig_types[191]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[192]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[193]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[194]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[195]
#define SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[196]
#define SWIGTYPE_p_Ogre__ConstShadowTextureConfigIterator swig_types[197]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[198]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[199]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[200]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[201]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[202]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[203]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[204]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[205]
#define SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[206]
#define SWIGTYPE_p_Ogre__ControllerManager swig_types[207]
#define SWIGTYPE_p_Ogre__ControllerT_float_t swig_types[208]
#define SWIGTYPE_p_Ogre__ConvexBody swig_types[209]
#define SWIGTYPE_p_Ogre__CreateCompositorScriptCompilerEvent swig_types[210]
#define SWIGTYPE_p_Ogre__CreateGpuProgramScriptCompilerEvent swig_types[211]
#define SWIGTYPE_p_Ogre__CreateGpuSharedParametersScriptCompilerEvent swig_types[212]
#define SWIGTYPE_p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent swig_types[213]
#define SWIGTYPE_p_Ogre__CreateMaterialScriptCompilerEvent swig_types[214]
#define SWIGTYPE_p_Ogre__CreateParticleSystemScriptCompilerEvent swig_types[215]
#define SWIGTYPE_p_Ogre__CustomCompositionPass swig_types[216]
#define SWIGTYPE_p_Ogre__DDSCodec swig_types[217]
#define SWIGTYPE_p_Ogre__DataStream swig_types[218]
#define SWIGTYPE_p_Ogre__DefaultAxisAlignedBoxSceneQuery swig_types[219]
#define SWIGTYPE_p_Ogre__DefaultHardwareBufferManager swig_types[220]
#define SWIGTYPE_p_Ogre__DefaultHardwareBufferManagerBase swig_types[221]
#define SWIGTYPE_p_Ogre__DefaultHardwareIndexBuffer swig_types[222]
#define SWIGTYPE_p_Ogre__DefaultHardwareVertexBuffer swig_types[223]
#define SWIGTYPE_p_Ogre__DefaultIntersectionSceneQuery swig_types[224]
#define SWIGTYPE_p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery swig_types[225]
#define SWIGTYPE_p_Ogre__DefaultRaySceneQuery swig_types[226]
#define SWIGTYPE_p_Ogre__DefaultSceneManager swig_types[227]
#define SWIGTYPE_p_Ogre__DefaultSceneManagerFactory swig_types[228]
#define SWIGTYPE_p_Ogre__DefaultShadowCameraSetup swig_types[229]
#define SWIGTYPE_p_Ogre__DefaultSphereSceneQuery swig_types[230]
#define SWIGTYPE_p_Ogre__DefaultWorkQueueBase swig_types[231]
#define SWIGTYPE_p_Ogre__DeflateStream swig_types[232]
#define SWIGTYPE_p_Ogre__Degree swig_types[233]
#define SWIGTYPE_p_Ogre__DepthBuffer swig_types[234]
#define SWIGTYPE_p_Ogre__DistanceLodStrategy swig_types[235]
#define SWIGTYPE_p_Ogre__DriverVersion swig_types[236]
#define SWIGTYPE_p_Ogre__DualQuaternion swig_types[237]
#define SWIGTYPE_p_Ogre__DynLib swig_types[238]
#define SWIGTYPE_p_Ogre__DynLibManager swig_types[239]
#define SWIGTYPE_p_Ogre__EdgeData swig_types[240]
#define SWIGTYPE_p_Ogre__EdgeData__Triangle swig_types[241]
#define SWIGTYPE_p_Ogre__EdgeListBuilder swig_types[242]
#define SWIGTYPE_p_Ogre__EmbeddedZipArchiveFactory swig_types[243]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdAngle swig_types[244]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdColour swig_types[245]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdColourRangeEnd swig_types[246]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdColourRangeStart swig_types[247]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdDirection swig_types[248]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdDuration swig_types[249]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdEmissionRate swig_types[250]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdEmittedEmitter swig_types[251]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxDuration swig_types[252]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxRepeatDelay swig_types[253]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxTTL swig_types[254]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxVelocity swig_types[255]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMinDuration swig_types[256]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMinRepeatDelay swig_types[257]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMinTTL swig_types[258]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdMinVelocity swig_types[259]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdName swig_types[260]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdPosition swig_types[261]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdRepeatDelay swig_types[262]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdTTL swig_types[263]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdUp swig_types[264]
#define SWIGTYPE_p_Ogre__EmitterCommands__CmdVelocity swig_types[265]
#define SWIGTYPE_p_Ogre__Entity swig_types[266]
#define SWIGTYPE_p_Ogre__EntityFactory swig_types[267]
#define SWIGTYPE_p_Ogre__EntityMaterialLodChangedEvent swig_types[268]
#define SWIGTYPE_p_Ogre__EntityMeshLodChangedEvent swig_types[269]
#define SWIGTYPE_p_Ogre__Exception swig_types[270]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t swig_types[271]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t swig_types[272]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t swig_types[273]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t swig_types[274]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t swig_types[275]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t swig_types[276]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t swig_types[277]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t swig_types[278]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t swig_types[279]
#define SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t swig_types[280]
#define SWIGTYPE_p_Ogre__ExceptionFactory swig_types[281]
#define SWIGTYPE_p_Ogre__ExternalTextureSource swig_types[282]
#define SWIGTYPE_p_Ogre__ExternalTextureSourceManager swig_types[283]
#define SWIGTYPE_p_Ogre__FileHandleDataStream swig_types[284]
#define SWIGTYPE_p_Ogre__FileInfo swig_types[285]
#define SWIGTYPE_p_Ogre__FileNotFoundException swig_types[286]
#define SWIGTYPE_p_Ogre__FileStreamDataStream swig_types[287]
#define SWIGTYPE_p_Ogre__FileSystemArchive swig_types[288]
#define SWIGTYPE_p_Ogre__FileSystemArchiveFactory swig_types[289]
#define SWIGTYPE_p_Ogre__FloatGpuParameterControllerValue swig_types[290]
#define SWIGTYPE_p_Ogre__FocusedShadowCameraSetup swig_types[291]
#define SWIGTYPE_p_Ogre__Font swig_types[292]
#define SWIGTYPE_p_Ogre__FontManager swig_types[293]
#define SWIGTYPE_p_Ogre__FontPtr swig_types[294]
#define SWIGTYPE_p_Ogre__Font__GlyphInfo swig_types[295]
#define SWIGTYPE_p_Ogre__FrameEvent swig_types[296]
#define SWIGTYPE_p_Ogre__FrameListener swig_types[297]
#define SWIGTYPE_p_Ogre__FrameTimeControllerValue swig_types[298]
#define SWIGTYPE_p_Ogre__FreeImageCodec swig_types[299]
#define SWIGTYPE_p_Ogre__Frustum swig_types[300]
#define SWIGTYPE_p_Ogre__FrustumPlane swig_types[301]
#define SWIGTYPE_p_Ogre__GpuConstantDefinition swig_types[302]
#define SWIGTYPE_p_Ogre__GpuLogicalBufferStruct swig_types[303]
#define SWIGTYPE_p_Ogre__GpuLogicalIndexUse swig_types[304]
#define SWIGTYPE_p_Ogre__GpuNamedConstants swig_types[305]
#define SWIGTYPE_p_Ogre__GpuNamedConstantsSerializer swig_types[306]
#define SWIGTYPE_p_Ogre__GpuProgram swig_types[307]
#define SWIGTYPE_p_Ogre__GpuProgramManager swig_types[308]
#define SWIGTYPE_p_Ogre__GpuProgramParameters swig_types[309]
#define SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantDefinition swig_types[310]
#define SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantEntry swig_types[311]
#define SWIGTYPE_p_Ogre__GpuProgramPtr swig_types[312]
#define SWIGTYPE_p_Ogre__GpuProgramTranslator swig_types[313]
#define SWIGTYPE_p_Ogre__GpuProgramUsage swig_types[314]
#define SWIGTYPE_p_Ogre__GpuSharedParameters swig_types[315]
#define SWIGTYPE_p_Ogre__GpuSharedParametersUsage swig_types[316]
#define SWIGTYPE_p_Ogre__Grid2DPageStrategy swig_types[317]
#define SWIGTYPE_p_Ogre__Grid2DPageStrategyData swig_types[318]
#define SWIGTYPE_p_Ogre__Grid3DPageStrategy swig_types[319]
#define SWIGTYPE_p_Ogre__Grid3DPageStrategyData swig_types[320]
#define SWIGTYPE_p_Ogre__HardwareBuffer swig_types[321]
#define SWIGTYPE_p_Ogre__HardwareBufferLicensee swig_types[322]
#define SWIGTYPE_p_Ogre__HardwareBufferManager swig_types[323]
#define SWIGTYPE_p_Ogre__HardwareBufferManagerBase swig_types[324]
#define SWIGTYPE_p_Ogre__HardwareIndexBuffer swig_types[325]
#define SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr swig_types[326]
#define SWIGTYPE_p_Ogre__HardwareOcclusionQuery swig_types[327]
#define SWIGTYPE_p_Ogre__HardwarePixelBuffer swig_types[328]
#define SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr swig_types[329]
#define SWIGTYPE_p_Ogre__HardwareVertexBuffer swig_types[330]
#define SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr swig_types[331]
#define SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t swig_types[332]
#define SWIGTYPE_p_Ogre__HighLevelGpuProgram swig_types[333]
#define SWIGTYPE_p_Ogre__HighLevelGpuProgramFactory swig_types[334]
#define SWIGTYPE_p_Ogre__HighLevelGpuProgramManager swig_types[335]
#define SWIGTYPE_p_Ogre__HighLevelGpuProgramPtr swig_types[336]
#define SWIGTYPE_p_Ogre__IOException swig_types[337]
#define SWIGTYPE_p_Ogre__IlluminationPass swig_types[338]
#define SWIGTYPE_p_Ogre__Image swig_types[339]
#define SWIGTYPE_p_Ogre__ImageCodec swig_types[340]
#define SWIGTYPE_p_Ogre__ImportAbstractNode swig_types[341]
#define SWIGTYPE_p_Ogre__IndexData swig_types[342]
#define SWIGTYPE_p_Ogre__InstanceBatch swig_types[343]
#define SWIGTYPE_p_Ogre__InstanceBatchHW swig_types[344]
#define SWIGTYPE_p_Ogre__InstanceBatchHW_VTF swig_types[345]
#define SWIGTYPE_p_Ogre__InstanceBatchShader swig_types[346]
#define SWIGTYPE_p_Ogre__InstanceBatchVTF swig_types[347]
#define SWIGTYPE_p_Ogre__InstanceManager swig_types[348]
#define SWIGTYPE_p_Ogre__InstancedEntity swig_types[349]
#define SWIGTYPE_p_Ogre__InstancedGeometry swig_types[350]
#define SWIGTYPE_p_Ogre__InstancedGeometry__BatchInstanceIterator swig_types[351]
#define SWIGTYPE_p_Ogre__InternalErrorException swig_types[352]
#define SWIGTYPE_p_Ogre__IntersectionSceneQuery swig_types[353]
#define SWIGTYPE_p_Ogre__IntersectionSceneQueryListener swig_types[354]
#define SWIGTYPE_p_Ogre__IntersectionSceneQueryResult swig_types[355]
#define SWIGTYPE_p_Ogre__InvalidParametersException swig_types[356]
#define SWIGTYPE_p_Ogre__InvalidStateException swig_types[357]
#define SWIGTYPE_p_Ogre__ItemIdentityException swig_types[358]
#define SWIGTYPE_p_Ogre__KeyFrame swig_types[359]
#define SWIGTYPE_p_Ogre__LayerBlendModeEx swig_types[360]
#define SWIGTYPE_p_Ogre__LiSPSMShadowCameraSetup swig_types[361]
#define SWIGTYPE_p_Ogre__Light swig_types[362]
#define SWIGTYPE_p_Ogre__LightFactory swig_types[363]
#define SWIGTYPE_p_Ogre__LinkedSkeletonAnimationSource swig_types[364]
#define SWIGTYPE_p_Ogre__LodListener swig_types[365]
#define SWIGTYPE_p_Ogre__LodStrategy swig_types[366]
#define SWIGTYPE_p_Ogre__LodStrategyManager swig_types[367]
#define SWIGTYPE_p_Ogre__Log swig_types[368]
#define SWIGTYPE_p_Ogre__LogListener swig_types[369]
#define SWIGTYPE_p_Ogre__LogManager swig_types[370]
#define SWIGTYPE_p_Ogre__Log__Stream swig_types[371]
#define SWIGTYPE_p_Ogre__ManualObject swig_types[372]
#define SWIGTYPE_p_Ogre__ManualObjectFactory swig_types[373]
#define SWIGTYPE_p_Ogre__ManualObject__ManualObjectSection swig_types[374]
#define SWIGTYPE_p_Ogre__ManualResourceLoader swig_types[375]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t swig_types[376]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[377]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[378]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[379]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[380]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[381]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[382]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[383]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[384]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[385]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[386]
#define SWIGTYPE_p_Ogre__MapIteratorT_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_t swig_types[387]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[388]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[389]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[390]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[391]
#define SWIGTYPE_p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[392]
#define SWIGTYPE_p_Ogre__Material swig_types[393]
#define SWIGTYPE_p_Ogre__MaterialManager swig_types[394]
#define SWIGTYPE_p_Ogre__MaterialManager__Listener swig_types[395]
#define SWIGTYPE_p_Ogre__MaterialPtr swig_types[396]
#define SWIGTYPE_p_Ogre__MaterialScriptContext swig_types[397]
#define SWIGTYPE_p_Ogre__MaterialScriptProgramDefinition swig_types[398]
#define SWIGTYPE_p_Ogre__MaterialSerializer swig_types[399]
#define SWIGTYPE_p_Ogre__MaterialSerializer__Listener swig_types[400]
#define SWIGTYPE_p_Ogre__MaterialTranslator swig_types[401]
#define SWIGTYPE_p_Ogre__Math swig_types[402]
#define SWIGTYPE_p_Ogre__Matrix3 swig_types[403]
#define SWIGTYPE_p_Ogre__Matrix4 swig_types[404]
#define SWIGTYPE_p_Ogre__MemoryDataStream swig_types[405]
#define SWIGTYPE_p_Ogre__Mesh swig_types[406]
#define SWIGTYPE_p_Ogre__MeshLodUsage swig_types[407]
#define SWIGTYPE_p_Ogre__MeshManager swig_types[408]
#define SWIGTYPE_p_Ogre__MeshPtr swig_types[409]
#define SWIGTYPE_p_Ogre__MeshSerializer swig_types[410]
#define SWIGTYPE_p_Ogre__MeshSerializerListener swig_types[411]
#define SWIGTYPE_p_Ogre__MovableObject swig_types[412]
#define SWIGTYPE_p_Ogre__MovableObjectFactory swig_types[413]
#define SWIGTYPE_p_Ogre__MovableObjectLodChangedEvent swig_types[414]
#define SWIGTYPE_p_Ogre__MovableObject__Listener swig_types[415]
#define SWIGTYPE_p_Ogre__MovablePlane swig_types[416]
#define SWIGTYPE_p_Ogre__MultiRenderTarget swig_types[417]
#define SWIGTYPE_p_Ogre__NameGenerator swig_types[418]
#define SWIGTYPE_p_Ogre__NedPoolingImpl swig_types[419]
#define SWIGTYPE_p_Ogre__NedPoolingPolicy swig_types[420]
#define SWIGTYPE_p_Ogre__Node swig_types[421]
#define SWIGTYPE_p_Ogre__NodeAnimationTrack swig_types[422]
#define SWIGTYPE_p_Ogre__Node__DebugRenderable swig_types[423]
#define SWIGTYPE_p_Ogre__Node__Listener swig_types[424]
#define SWIGTYPE_p_Ogre__NumericAnimationTrack swig_types[425]
#define SWIGTYPE_p_Ogre__NumericKeyFrame swig_types[426]
#define SWIGTYPE_p_Ogre__ObjectAbstractNode swig_types[427]
#define SWIGTYPE_p_Ogre__OptimisedUtil swig_types[428]
#define SWIGTYPE_p_Ogre__Overlay swig_types[429]
#define SWIGTYPE_p_Ogre__OverlayContainer swig_types[430]
#define SWIGTYPE_p_Ogre__OverlayElement swig_types[431]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdCaption swig_types[432]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdHeight swig_types[433]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdHorizontalAlign swig_types[434]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdLeft swig_types[435]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdMaterial swig_types[436]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdMetricsMode swig_types[437]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdTop swig_types[438]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdVerticalAlign swig_types[439]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdVisible swig_types[440]
#define SWIGTYPE_p_Ogre__OverlayElementCommands__CmdWidth swig_types[441]
#define SWIGTYPE_p_Ogre__OverlayElementFactory swig_types[442]
#define SWIGTYPE_p_Ogre__OverlayManager swig_types[443]
#define SWIGTYPE_p_Ogre__PSSMShadowCameraSetup swig_types[444]
#define SWIGTYPE_p_Ogre__Page swig_types[445]
#define SWIGTYPE_p_Ogre__PageContent swig_types[446]
#define SWIGTYPE_p_Ogre__PageContentCollection swig_types[447]
#define SWIGTYPE_p_Ogre__PageContentCollectionFactory swig_types[448]
#define SWIGTYPE_p_Ogre__PageContentFactory swig_types[449]
#define SWIGTYPE_p_Ogre__PageManager swig_types[450]
#define SWIGTYPE_p_Ogre__PageProvider swig_types[451]
#define SWIGTYPE_p_Ogre__PageStrategy swig_types[452]
#define SWIGTYPE_p_Ogre__PageStrategyData swig_types[453]
#define SWIGTYPE_p_Ogre__PagedWorld swig_types[454]
#define SWIGTYPE_p_Ogre__PagedWorldSection swig_types[455]
#define SWIGTYPE_p_Ogre__PagedWorldSectionFactory swig_types[456]
#define SWIGTYPE_p_Ogre__PanelOverlayElement swig_types[457]
#define SWIGTYPE_p_Ogre__PanelOverlayElementFactory swig_types[458]
#define SWIGTYPE_p_Ogre__ParamCommand swig_types[459]
#define SWIGTYPE_p_Ogre__ParamDictionary swig_types[460]
#define SWIGTYPE_p_Ogre__ParameterDef swig_types[461]
#define SWIGTYPE_p_Ogre__Particle swig_types[462]
#define SWIGTYPE_p_Ogre__ParticleAffector swig_types[463]
#define SWIGTYPE_p_Ogre__ParticleAffectorFactory swig_types[464]
#define SWIGTYPE_p_Ogre__ParticleAffectorTranslator swig_types[465]
#define SWIGTYPE_p_Ogre__ParticleEmitter swig_types[466]
#define SWIGTYPE_p_Ogre__ParticleEmitterFactory swig_types[467]
#define SWIGTYPE_p_Ogre__ParticleEmitterTranslator swig_types[468]
#define SWIGTYPE_p_Ogre__ParticleIterator swig_types[469]
#define SWIGTYPE_p_Ogre__ParticleSystem swig_types[470]
#define SWIGTYPE_p_Ogre__ParticleSystemFactory swig_types[471]
#define SWIGTYPE_p_Ogre__ParticleSystemManager swig_types[472]
#define SWIGTYPE_p_Ogre__ParticleSystemRenderer swig_types[473]
#define SWIGTYPE_p_Ogre__ParticleSystemRendererFactory swig_types[474]
#define SWIGTYPE_p_Ogre__ParticleSystemTranslator swig_types[475]
#define SWIGTYPE_p_Ogre__ParticleVisualData swig_types[476]
#define SWIGTYPE_p_Ogre__Pass swig_types[477]
#define SWIGTYPE_p_Ogre__PassTranslator swig_types[478]
#define SWIGTYPE_p_Ogre__Pass__HashFunc swig_types[479]
#define SWIGTYPE_p_Ogre__PassthroughControllerFunction swig_types[480]
#define SWIGTYPE_p_Ogre__PatchMesh swig_types[481]
#define SWIGTYPE_p_Ogre__PatchMeshPtr swig_types[482]
#define SWIGTYPE_p_Ogre__PatchSurface swig_types[483]
#define SWIGTYPE_p_Ogre__PixelBox swig_types[484]
#define SWIGTYPE_p_Ogre__PixelCountLodStrategy swig_types[485]
#define SWIGTYPE_p_Ogre__PixelUtil swig_types[486]
#define SWIGTYPE_p_Ogre__Plane swig_types[487]
#define SWIGTYPE_p_Ogre__PlaneBoundedVolume swig_types[488]
#define SWIGTYPE_p_Ogre__PlaneBoundedVolumeListSceneQuery swig_types[489]
#define SWIGTYPE_p_Ogre__PlaneOptimalShadowCameraSetup swig_types[490]
#define SWIGTYPE_p_Ogre__PlatformInformation swig_types[491]
#define SWIGTYPE_p_Ogre__Plugin swig_types[492]
#define SWIGTYPE_p_Ogre__Polygon swig_types[493]
#define SWIGTYPE_p_Ogre__Pose swig_types[494]
#define SWIGTYPE_p_Ogre__PreApplyTextureAliasesScriptCompilerEvent swig_types[495]
#define SWIGTYPE_p_Ogre__PrefabFactory swig_types[496]
#define SWIGTYPE_p_Ogre__ProcessNameExclusionScriptCompilerEvent swig_types[497]
#define SWIGTYPE_p_Ogre__ProcessResourceNameScriptCompilerEvent swig_types[498]
#define SWIGTYPE_p_Ogre__Profile swig_types[499]
#define SWIGTYPE_p_Ogre__Profiler swig_types[500]
#define SWIGTYPE_p_Ogre__PropertyAbstractNode swig_types[501]
#define SWIGTYPE_p_Ogre__Quaternion swig_types[502]
#define SWIGTYPE_p_Ogre__QueuedRenderableCollection swig_types[503]
#define SWIGTYPE_p_Ogre__QueuedRenderableVisitor swig_types[504]
#define SWIGTYPE_p_Ogre__Radian swig_types[505]
#define SWIGTYPE_p_Ogre__Ray swig_types[506]
#define SWIGTYPE_p_Ogre__RaySceneQuery swig_types[507]
#define SWIGTYPE_p_Ogre__RaySceneQueryListener swig_types[508]
#define SWIGTYPE_p_Ogre__RaySceneQueryResultEntry swig_types[509]
#define SWIGTYPE_p_Ogre__Rectangle swig_types[510]
#define SWIGTYPE_p_Ogre__Rectangle2D swig_types[511]
#define SWIGTYPE_p_Ogre__RegionSceneQuery swig_types[512]
#define SWIGTYPE_p_Ogre__RenderObjectListener swig_types[513]
#define SWIGTYPE_p_Ogre__RenderOperation swig_types[514]
#define SWIGTYPE_p_Ogre__RenderPriorityGroup swig_types[515]
#define SWIGTYPE_p_Ogre__RenderQueue swig_types[516]
#define SWIGTYPE_p_Ogre__RenderQueueGroup swig_types[517]
#define SWIGTYPE_p_Ogre__RenderQueueGroup__ConstPriorityMapIterator swig_types[518]
#define SWIGTYPE_p_Ogre__RenderQueueGroup__PriorityMapIterator swig_types[519]
#define SWIGTYPE_p_Ogre__RenderQueueInvocation swig_types[520]
#define SWIGTYPE_p_Ogre__RenderQueueInvocationSequence swig_types[521]
#define SWIGTYPE_p_Ogre__RenderQueueListener swig_types[522]
#define SWIGTYPE_p_Ogre__RenderQueue__RenderableListener swig_types[523]
#define SWIGTYPE_p_Ogre__RenderSystem swig_types[524]
#define SWIGTYPE_p_Ogre__RenderSystemCapabilities swig_types[525]
#define SWIGTYPE_p_Ogre__RenderSystemCapabilitiesManager swig_types[526]
#define SWIGTYPE_p_Ogre__RenderSystemCapabilitiesSerializer swig_types[527]
#define SWIGTYPE_p_Ogre__RenderSystem__Listener swig_types[528]
#define SWIGTYPE_p_Ogre__RenderSystem__RenderSystemContext swig_types[529]
#define SWIGTYPE_p_Ogre__RenderTarget swig_types[530]
#define SWIGTYPE_p_Ogre__RenderTargetEvent swig_types[531]
#define SWIGTYPE_p_Ogre__RenderTargetListener swig_types[532]
#define SWIGTYPE_p_Ogre__RenderTargetViewportEvent swig_types[533]
#define SWIGTYPE_p_Ogre__RenderTarget__FrameStats swig_types[534]
#define SWIGTYPE_p_Ogre__RenderTarget__Impl swig_types[535]
#define SWIGTYPE_p_Ogre__RenderTexture swig_types[536]
#define SWIGTYPE_p_Ogre__RenderToVertexBuffer swig_types[537]
#define SWIGTYPE_p_Ogre__RenderWindow swig_types[538]
#define SWIGTYPE_p_Ogre__RenderWindowDescription swig_types[539]
#define SWIGTYPE_p_Ogre__Renderable swig_types[540]
#define SWIGTYPE_p_Ogre__RenderablePass swig_types[541]
#define SWIGTYPE_p_Ogre__Renderable__RenderSystemData swig_types[542]
#define SWIGTYPE_p_Ogre__Renderable__Visitor swig_types[543]
#define SWIGTYPE_p_Ogre__RenderingAPIException swig_types[544]
#define SWIGTYPE_p_Ogre__Resource swig_types[545]
#define SWIGTYPE_p_Ogre__ResourceBackgroundQueue swig_types[546]
#define SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener swig_types[547]
#define SWIGTYPE_p_Ogre__ResourceGroupListener swig_types[548]
#define SWIGTYPE_p_Ogre__ResourceGroupManager swig_types[549]
#define SWIGTYPE_p_Ogre__ResourceGroupManager__ResourceManagerIterator swig_types[550]
#define SWIGTYPE_p_Ogre__ResourceLoadingListener swig_types[551]
#define SWIGTYPE_p_Ogre__ResourceManager swig_types[552]
#define SWIGTYPE_p_Ogre__ResourceManager__ResourceMapIterator swig_types[553]
#define SWIGTYPE_p_Ogre__ResourceManager__ResourcePool swig_types[554]
#define SWIGTYPE_p_Ogre__Resource__Listener swig_types[555]
#define SWIGTYPE_p_Ogre__RibbonTrail swig_types[556]
#define SWIGTYPE_p_Ogre__RibbonTrailFactory swig_types[557]
#define SWIGTYPE_p_Ogre__Root swig_types[558]
#define SWIGTYPE_p_Ogre__Root__MovableObjectFactoryIterator swig_types[559]
#define SWIGTYPE_p_Ogre__RotationalSpline swig_types[560]
#define SWIGTYPE_p_Ogre__RuntimeAssertionException swig_types[561]
#define SWIGTYPE_p_Ogre__ScaleControllerFunction swig_types[562]
#define SWIGTYPE_p_Ogre__SceneManager swig_types[563]
#define SWIGTYPE_p_Ogre__SceneManagerEnumerator swig_types[564]
#define SWIGTYPE_p_Ogre__SceneManagerEnumerator__MetaDataIterator swig_types[565]
#define SWIGTYPE_p_Ogre__SceneManagerEnumerator__SceneManagerIterator swig_types[566]
#define SWIGTYPE_p_Ogre__SceneManagerFactory swig_types[567]
#define SWIGTYPE_p_Ogre__SceneManagerMetaData swig_types[568]
#define SWIGTYPE_p_Ogre__SceneManager__AnimationIterator swig_types[569]
#define SWIGTYPE_p_Ogre__SceneManager__CameraIterator swig_types[570]
#define SWIGTYPE_p_Ogre__SceneManager__Listener swig_types[571]
#define SWIGTYPE_p_Ogre__SceneManager__MovableObjectIterator swig_types[572]
#define SWIGTYPE_p_Ogre__SceneManager__RenderContext swig_types[573]
#define SWIGTYPE_p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor swig_types[574]
#define SWIGTYPE_p_Ogre__SceneManager__SkyBoxGenParameters swig_types[575]
#define SWIGTYPE_p_Ogre__SceneManager__SkyDomeGenParameters swig_types[576]
#define SWIGTYPE_p_Ogre__SceneManager__SkyPlaneGenParameters swig_types[577]
#define SWIGTYPE_p_Ogre__SceneNode swig_types[578]
#define SWIGTYPE_p_Ogre__SceneQuery swig_types[579]
#define SWIGTYPE_p_Ogre__SceneQueryListener swig_types[580]
#define SWIGTYPE_p_Ogre__SceneQueryResult swig_types[581]
#define SWIGTYPE_p_Ogre__SceneQuery__WorldFragment swig_types[582]
#define SWIGTYPE_p_Ogre__ScriptCompiler swig_types[583]
#define SWIGTYPE_p_Ogre__ScriptCompilerEvent swig_types[584]
#define SWIGTYPE_p_Ogre__ScriptCompilerListener swig_types[585]
#define SWIGTYPE_p_Ogre__ScriptCompilerManager swig_types[586]
#define SWIGTYPE_p_Ogre__ScriptLexer swig_types[587]
#define SWIGTYPE_p_Ogre__ScriptLoader swig_types[588]
#define SWIGTYPE_p_Ogre__ScriptParser swig_types[589]
#define SWIGTYPE_p_Ogre__ScriptToken swig_types[590]
#define SWIGTYPE_p_Ogre__ScriptTranslator swig_types[591]
#define SWIGTYPE_p_Ogre__ScriptTranslatorManager swig_types[592]
#define SWIGTYPE_p_Ogre__Serializer swig_types[593]
#define SWIGTYPE_p_Ogre__ShadowCameraSetup swig_types[594]
#define SWIGTYPE_p_Ogre__ShadowCaster swig_types[595]
#define SWIGTYPE_p_Ogre__ShadowRenderable swig_types[596]
#define SWIGTYPE_p_Ogre__ShadowTextureConfig swig_types[597]
#define SWIGTYPE_p_Ogre__ShadowTextureManager swig_types[598]
#define SWIGTYPE_p_Ogre__ShadowVolumeExtrudeProgram swig_types[599]
#define SWIGTYPE_p_Ogre__SharedParamsTranslator swig_types[600]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t swig_types[601]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t swig_types[602]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__CodecData_t swig_types[603]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ConcreteNode_t swig_types[604]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t swig_types[605]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t swig_types[606]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t swig_types[607]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t swig_types[608]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t swig_types[609]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t swig_types[610]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t swig_types[611]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t swig_types[612]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t swig_types[613]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t swig_types[614]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t swig_types[615]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t swig_types[616]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ScriptToken_t swig_types[617]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t swig_types[618]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t swig_types[619]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[620]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[621]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[622]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[623]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[624]
#define SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[625]
#define SWIGTYPE_p_Ogre__SimplePageContentCollection swig_types[626]
#define SWIGTYPE_p_Ogre__SimplePageContentCollectionFactory swig_types[627]
#define SWIGTYPE_p_Ogre__SimpleRenderable swig_types[628]
#define SWIGTYPE_p_Ogre__SimpleSpline swig_types[629]
#define SWIGTYPE_p_Ogre__Skeleton swig_types[630]
#define SWIGTYPE_p_Ogre__SkeletonInstance swig_types[631]
#define SWIGTYPE_p_Ogre__SkeletonManager swig_types[632]
#define SWIGTYPE_p_Ogre__SkeletonPtr swig_types[633]
#define SWIGTYPE_p_Ogre__SkeletonSerializer swig_types[634]
#define SWIGTYPE_p_Ogre__Sphere swig_types[635]
#define SWIGTYPE_p_Ogre__SphereSceneQuery swig_types[636]
#define SWIGTYPE_p_Ogre__StaticFaceGroup swig_types[637]
#define SWIGTYPE_p_Ogre__StaticGeometry swig_types[638]
#define SWIGTYPE_p_Ogre__StaticPluginLoader swig_types[639]
#define SWIGTYPE_p_Ogre__StreamSerialiser swig_types[640]
#define SWIGTYPE_p_Ogre__StreamSerialiser__Chunk swig_types[641]
#define SWIGTYPE_p_Ogre__StringConverter swig_types[642]
#define SWIGTYPE_p_Ogre__StringInterface swig_types[643]
#define SWIGTYPE_p_Ogre__StringUtil swig_types[644]
#define SWIGTYPE_p_Ogre__SubEntity swig_types[645]
#define SWIGTYPE_p_Ogre__SubMesh swig_types[646]
#define SWIGTYPE_p_Ogre__TRectT_float_t swig_types[647]
#define SWIGTYPE_p_Ogre__TRectT_long_t swig_types[648]
#define SWIGTYPE_p_Ogre__TagPoint swig_types[649]
#define SWIGTYPE_p_Ogre__TangentSpaceCalc swig_types[650]
#define SWIGTYPE_p_Ogre__TangentSpaceCalc__Result swig_types[651]
#define SWIGTYPE_p_Ogre__Technique swig_types[652]
#define SWIGTYPE_p_Ogre__TechniqueTranslator swig_types[653]
#define SWIGTYPE_p_Ogre__TempBlendedBufferInfo swig_types[654]
#define SWIGTYPE_p_Ogre__Terrain swig_types[655]
#define SWIGTYPE_p_Ogre__TerrainGlobalOptions swig_types[656]
#define SWIGTYPE_p_Ogre__TerrainGroup swig_types[657]
#define SWIGTYPE_p_Ogre__TerrainGroup__RayResult swig_types[658]
#define SWIGTYPE_p_Ogre__TerrainGroup__TerrainSlotDefinition swig_types[659]
#define SWIGTYPE_p_Ogre__TerrainLayerBlendMap swig_types[660]
#define SWIGTYPE_p_Ogre__TerrainLayerDeclaration swig_types[661]
#define SWIGTYPE_p_Ogre__TerrainLayerSampler swig_types[662]
#define SWIGTYPE_p_Ogre__TerrainLayerSamplerElement swig_types[663]
#define SWIGTYPE_p_Ogre__TerrainMaterialGenerator swig_types[664]
#define SWIGTYPE_p_Ogre__TerrainMaterialGeneratorA swig_types[665]
#define SWIGTYPE_p_Ogre__TerrainMaterialGenerator__Profile swig_types[666]
#define SWIGTYPE_p_Ogre__TerrainPagedWorldSection swig_types[667]
#define SWIGTYPE_p_Ogre__TerrainPaging swig_types[668]
#define SWIGTYPE_p_Ogre__TerrainQuadTreeNode swig_types[669]
#define SWIGTYPE_p_Ogre__TerrainQuadTreeNode__LodLevel swig_types[670]
#define SWIGTYPE_p_Ogre__Terrain__GpuBufferAllocator swig_types[671]
#define SWIGTYPE_p_Ogre__Terrain__ImportData swig_types[672]
#define SWIGTYPE_p_Ogre__TexCoordModifierControllerValue swig_types[673]
#define SWIGTYPE_p_Ogre__TextAreaOverlayElement swig_types[674]
#define SWIGTYPE_p_Ogre__TextAreaOverlayElementFactory swig_types[675]
#define SWIGTYPE_p_Ogre__Texture swig_types[676]
#define SWIGTYPE_p_Ogre__TextureFrameControllerValue swig_types[677]
#define SWIGTYPE_p_Ogre__TextureManager swig_types[678]
#define SWIGTYPE_p_Ogre__TexturePtr swig_types[679]
#define SWIGTYPE_p_Ogre__TextureSourceTranslator swig_types[680]
#define SWIGTYPE_p_Ogre__TextureUnitState swig_types[681]
#define SWIGTYPE_p_Ogre__TextureUnitState__TextureEffect swig_types[682]
#define SWIGTYPE_p_Ogre__TextureUnitState__UVWAddressingMode swig_types[683]
#define SWIGTYPE_p_Ogre__TextureUnitTranslator swig_types[684]
#define SWIGTYPE_p_Ogre__TimeIndex swig_types[685]
#define SWIGTYPE_p_Ogre__Timer swig_types[686]
#define SWIGTYPE_p_Ogre__TransformKeyFrame swig_types[687]
#define SWIGTYPE_p_Ogre__UTFString swig_types[688]
#define SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator swig_types[689]
#define SWIGTYPE_p_Ogre__UTFString___const_rev_iterator swig_types[690]
#define SWIGTYPE_p_Ogre__UTFString___fwd_iterator swig_types[691]
#define SWIGTYPE_p_Ogre__UTFString___rev_iterator swig_types[692]
#define SWIGTYPE_p_Ogre__UnifiedHighLevelGpuProgram swig_types[693]
#define SWIGTYPE_p_Ogre__UnifiedHighLevelGpuProgramFactory swig_types[694]
#define SWIGTYPE_p_Ogre__UnimplementedException swig_types[695]
#define SWIGTYPE_p_Ogre__UserObjectBindings swig_types[696]
#define SWIGTYPE_p_Ogre__VariableAccessAbstractNode swig_types[697]
#define SWIGTYPE_p_Ogre__Vector2 swig_types[698]
#define SWIGTYPE_p_Ogre__Vector3 swig_types[699]
#define SWIGTYPE_p_Ogre__Vector4 swig_types[700]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[701]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[702]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[703]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[704]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[705]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[706]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[707]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[708]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[709]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[710]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[711]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[712]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[713]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[714]
#define SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t swig_types[715]
#define SWIGTYPE_p_Ogre__VertexAnimationTrack swig_types[716]
#define SWIGTYPE_p_Ogre__VertexBoneAssignment_s swig_types[717]
#define SWIGTYPE_p_Ogre__VertexBufferBinding swig_types[718]
#define SWIGTYPE_p_Ogre__VertexCacheProfiler swig_types[719]
#define SWIGTYPE_p_Ogre__VertexData swig_types[720]
#define SWIGTYPE_p_Ogre__VertexDeclaration swig_types[721]
#define SWIGTYPE_p_Ogre__VertexElement swig_types[722]
#define SWIGTYPE_p_Ogre__VertexMorphKeyFrame swig_types[723]
#define SWIGTYPE_p_Ogre__VertexPoseKeyFrame swig_types[724]
#define SWIGTYPE_p_Ogre__ViewPoint swig_types[725]
#define SWIGTYPE_p_Ogre__Viewport swig_types[726]
#define SWIGTYPE_p_Ogre__Viewport__Listener swig_types[727]
#define SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo swig_types[728]
#define SWIGTYPE_p_Ogre__WaveformControllerFunction swig_types[729]
#define SWIGTYPE_p_Ogre__WindowEventListener swig_types[730]
#define SWIGTYPE_p_Ogre__WindowEventUtilities swig_types[731]
#define SWIGTYPE_p_Ogre__WireBoundingBox swig_types[732]
#define SWIGTYPE_p_Ogre__WorkQueue swig_types[733]
#define SWIGTYPE_p_Ogre__WorkQueue__Request swig_types[734]
#define SWIGTYPE_p_Ogre__WorkQueue__RequestHandler swig_types[735]
#define SWIGTYPE_p_Ogre__WorkQueue__Response swig_types[736]
#define SWIGTYPE_p_Ogre__WorkQueue__ResponseHandler swig_types[737]
#define SWIGTYPE_p_Ogre__ZipArchive swig_types[738]
#define SWIGTYPE_p_Ogre__ZipArchiveFactory swig_types[739]
#define SWIGTYPE_p_Ogre__ZipDataStream swig_types[740]
#define SWIGTYPE_p_Ogre___ConfigOption swig_types[741]
#define SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[742]
#define SWIGTYPE_p_Ogre__listT_Ogre__AnimationState_p_Ogre__STLAllocatorT_Ogre__AnimationState_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[743]
#define SWIGTYPE_p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[744]
#define SWIGTYPE_p_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[745]
#define SWIGTYPE_p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[746]
#define SWIGTYPE_p_Ogre__listT_Ogre__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[747]
#define SWIGTYPE_p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type swig_types[748]
#define SWIGTYPE_p_Ogre__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[749]
#define SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type swig_types[750]
#define SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type swig_types[751]
#define SWIGTYPE_p_Ogre__listT_Ogre__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_Ogre__GeneralAllocPolicy_t_t__type swig_types[752]
#define SWIGTYPE_p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[753]
#define SWIGTYPE_p_Ogre__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_Ogre__GeneralAllocPolicy_t_t__type swig_types[754]
#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[755]
#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[756]
#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[757]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[758]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[759]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[760]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[761]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[762]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[763]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[764]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[765]
#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[766]
#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[767]
#define SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[768]
#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[769]
#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[770]
#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[771]
#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[772]
#define SWIGTYPE_p_Ogre__mapT_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[773]
#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[774]
#define SWIGTYPE_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[775]
#define SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[776]
#define SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[777]
#define SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[778]
#define SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[779]
#define SWIGTYPE_p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[780]
#define SWIGTYPE_p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[781]
#define SWIGTYPE_p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[782]
#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[783]
#define SWIGTYPE_p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[784]
#define SWIGTYPE_p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[785]
#define SWIGTYPE_p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[786]
#define SWIGTYPE_p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type swig_types[787]
#define SWIGTYPE_p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type swig_types[788]
#define SWIGTYPE_p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[789]
#define SWIGTYPE_p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type swig_types[790]
#define SWIGTYPE_p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type swig_types[791]
#define SWIGTYPE_p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type swig_types[792]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[793]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__DepthBuffer_p_Ogre__STLAllocatorT_Ogre__DepthBuffer_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[794]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_Ogre__GeneralAllocPolicy_t_t__type swig_types[795]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type swig_types[796]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type swig_types[797]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type swig_types[798]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_Ogre__GeneralAllocPolicy_t_t__type swig_types[799]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type swig_types[800]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[801]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[802]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Image_p_Ogre__STLAllocatorT_Ogre__Image_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[803]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[804]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[805]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type swig_types[806]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[807]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[808]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type swig_types[809]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__PixelFormat_Ogre__STLAllocatorT_Ogre__PixelFormat_Ogre__GeneralAllocPolicy_t_t__type swig_types[810]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type swig_types[811]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type swig_types[812]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[813]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[814]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[815]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type swig_types[816]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type swig_types[817]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[818]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[819]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[820]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[821]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type swig_types[822]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[823]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[824]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type swig_types[825]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type swig_types[826]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_Ogre__GeneralAllocPolicy_t_t__type swig_types[827]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerBlendMap_p_Ogre__STLAllocatorT_Ogre__TerrainLayerBlendMap_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[828]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type swig_types[829]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type swig_types[830]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type swig_types[831]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type swig_types[832]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type swig_types[833]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type swig_types[834]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type swig_types[835]
#define SWIGTYPE_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type swig_types[836]
#define SWIGTYPE_p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type swig_types[837]
#define SWIGTYPE_p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_Ogre__GeneralAllocPolicy_t_t__type swig_types[838]
#define SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type swig_types[839]
#define SWIGTYPE_p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type swig_types[840]
#define SWIGTYPE_p_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type swig_types[841]
#define SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type swig_types[842]
#define SWIGTYPE_p_OptimalAdjustFactorList swig_types[843]
#define SWIGTYPE_p_OptimisedSubMeshGeometryList swig_types[844]
#define SWIGTYPE_p_Overlay2DElementsIterator swig_types[845]
#define SWIGTYPE_p_OverlayContainerList swig_types[846]
#define SWIGTYPE_p_OverlayMap swig_types[847]
#define SWIGTYPE_p_OverlayMapIterator swig_types[848]
#define SWIGTYPE_p_PageMap swig_types[849]
#define SWIGTYPE_p_ParticleAffectorFactoryIterator swig_types[850]
#define SWIGTYPE_p_ParticleAffectorFactoryMap swig_types[851]
#define SWIGTYPE_p_ParticleEmitterFactoryIterator swig_types[852]
#define SWIGTYPE_p_ParticleEmitterFactoryMap swig_types[853]
#define SWIGTYPE_p_ParticleRendererFactoryIterator swig_types[854]
#define SWIGTYPE_p_ParticleSystemRendererFactoryMap swig_types[855]
#define SWIGTYPE_p_ParticleSystemTemplateIterator swig_types[856]
#define SWIGTYPE_p_ParticleTemplateMap swig_types[857]
#define SWIGTYPE_p_PassIterator swig_types[858]
#define SWIGTYPE_p_PassSet swig_types[859]
#define SWIGTYPE_p_Passes swig_types[860]
#define SWIGTYPE_p_PlaneList swig_types[861]
#define SWIGTYPE_p_PluginInstanceList swig_types[862]
#define SWIGTYPE_p_PluginLibList swig_types[863]
#define SWIGTYPE_p_PolygonList swig_types[864]
#define SWIGTYPE_p_PoseIterator swig_types[865]
#define SWIGTYPE_p_PoseRefIterator swig_types[866]
#define SWIGTYPE_p_PoseRefList swig_types[867]
#define SWIGTYPE_p_PriorityMap swig_types[868]
#define SWIGTYPE_p_PriorityMapIterator swig_types[869]
#define SWIGTYPE_p_ProfileList swig_types[870]
#define SWIGTYPE_p_QuadMaterialMap swig_types[871]
#define SWIGTYPE_p_QueueGroupIterator swig_types[872]
#define SWIGTYPE_p_QueuedGeometryList swig_types[873]
#define SWIGTYPE_p_QueuedSubMeshList swig_types[874]
#define SWIGTYPE_p_QueuedSubMeshOriginList swig_types[875]
#define SWIGTYPE_p_RealVector swig_types[876]
#define SWIGTYPE_p_Rect swig_types[877]
#define SWIGTYPE_p_RegionIterator swig_types[878]
#define SWIGTYPE_p_RegionMap swig_types[879]
#define SWIGTYPE_p_RenderOperationVector swig_types[880]
#define SWIGTYPE_p_RenderSystemOpPair swig_types[881]
#define SWIGTYPE_p_RenderSystemOpPairs swig_types[882]
#define SWIGTYPE_p_RenderTargetIterator swig_types[883]
#define SWIGTYPE_p_RequestID swig_types[884]
#define SWIGTYPE_p_ResourceCreateOrRetrieveResult swig_types[885]
#define SWIGTYPE_p_ResourceDeclarationList swig_types[886]
#define SWIGTYPE_p_ResourceHandleMap swig_types[887]
#define SWIGTYPE_p_ResourceManagerIterator swig_types[888]
#define SWIGTYPE_p_ResourceManagerMap swig_types[889]
#define SWIGTYPE_p_ResourceMap swig_types[890]
#define SWIGTYPE_p_ResourceMapIterator swig_types[891]
#define SWIGTYPE_p_ResourcePool swig_types[892]
#define SWIGTYPE_p_ResourceWithGroupMap swig_types[893]
#define SWIGTYPE_p_SceneManagerIterator swig_types[894]
#define SWIGTYPE_p_SchemeHardwareAnimMap swig_types[895]
#define SWIGTYPE_p_SectionIterator swig_types[896]
#define SWIGTYPE_p_SectionList swig_types[897]
#define SWIGTYPE_p_SectionMap swig_types[898]
#define SWIGTYPE_p_SettingsBySection swig_types[899]
#define SWIGTYPE_p_SettingsIterator swig_types[900]
#define SWIGTYPE_p_SettingsMultiMap swig_types[901]
#define SWIGTYPE_p_ShaderProfiles swig_types[902]
#define SWIGTYPE_p_ShadowRenderableList swig_types[903]
#define SWIGTYPE_p_ShadowRenderableListIterator swig_types[904]
#define SWIGTYPE_p_SharedParametersMap swig_types[905]
#define SWIGTYPE_p_SplitPointList swig_types[906]
#define SWIGTYPE_p_StrStreamType swig_types[907]
#define SWIGTYPE_p_StrategyMap swig_types[908]
#define SWIGTYPE_p_SubMeshGeometryLookup swig_types[909]
#define SWIGTYPE_p_SubMeshIterator swig_types[910]
#define SWIGTYPE_p_SubMeshList swig_types[911]
#define SWIGTYPE_p_SubMeshLodGeometryLinkList swig_types[912]
#define SWIGTYPE_p_SubMeshNameMap swig_types[913]
#define SWIGTYPE_p_SyntaxCodes swig_types[914]
#define SWIGTYPE_p_TargetPassIterator swig_types[915]
#define SWIGTYPE_p_TargetPasses swig_types[916]
#define SWIGTYPE_p_TechniqueIterator swig_types[917]
#define SWIGTYPE_p_Techniques swig_types[918]
#define SWIGTYPE_p_TemplateIterator swig_types[919]
#define SWIGTYPE_p_TerrainIterator swig_types[920]
#define SWIGTYPE_p_TerrainList swig_types[921]
#define SWIGTYPE_p_TerrainSlotMap swig_types[922]
#define SWIGTYPE_p_TextureDefinitionIterator swig_types[923]
#define SWIGTYPE_p_TextureDefinitions swig_types[924]
#define SWIGTYPE_p_TextureUnitStateIterator swig_types[925]
#define SWIGTYPE_p_TrackHandleList swig_types[926]
#define SWIGTYPE_p_TriangleFaceNormalList swig_types[927]
#define SWIGTYPE_p_TriangleLightFacingList swig_types[928]
#define SWIGTYPE_p_TriangleList swig_types[929]
#define SWIGTYPE_p_UVRect swig_types[930]
#define SWIGTYPE_p_UniqueTextureSet swig_types[931]
#define SWIGTYPE_p_VertexBoneAssignmentList swig_types[932]
#define SWIGTYPE_p_VertexBufferBindingMap swig_types[933]
#define SWIGTYPE_p_VertexElementList swig_types[934]
#define SWIGTYPE_p_VertexList swig_types[935]
#define SWIGTYPE_p_VertexOffsetIterator swig_types[936]
#define SWIGTYPE_p_VertexOffsetMap swig_types[937]
#define SWIGTYPE_p_VertexSplit swig_types[938]
#define SWIGTYPE_p_VertexSplits swig_types[939]
#define SWIGTYPE_p_VertexTrackIterator swig_types[940]
#define SWIGTYPE_p_VertexTrackList swig_types[941]
#define SWIGTYPE_p_WindowEventListeners swig_types[942]
#define SWIGTYPE_p_Windows swig_types[943]
#define SWIGTYPE_p_WorldMap swig_types[944]
#define SWIGTYPE_p_WorldSectionFactoryMap swig_types[945]
#define SWIGTYPE_p__zzip_plugin_io swig_types[946]
#define SWIGTYPE_p_a_3__float swig_types[947]
#define SWIGTYPE_p_bool swig_types[948]
#define SWIGTYPE_p_char swig_types[949]
#define SWIGTYPE_p_code_point swig_types[950]
#define SWIGTYPE_p_const_iterator swig_types[951]
#define SWIGTYPE_p_const_reverse_iterator swig_types[952]
#define SWIGTYPE_p_double swig_types[953]
#define SWIGTYPE_p_dstring swig_types[954]
#define SWIGTYPE_p_f_size_t_p_void_size_t__bool swig_types[955]
#define SWIGTYPE_p_float swig_types[956]
#define SWIGTYPE_p_int swig_types[957]
#define SWIGTYPE_p_iterator swig_types[958]
#define SWIGTYPE_p_long swig_types[959]
#define SWIGTYPE_p_long_long swig_types[960]
#define SWIGTYPE_p_p_Ogre__KeyFrame swig_types[961]
#define SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource swig_types[962]
#define SWIGTYPE_p_p_Ogre__Matrix4 swig_types[963]
#define SWIGTYPE_p_p_Ogre__NumericKeyFrame swig_types[964]
#define SWIGTYPE_p_p_Ogre__Terrain swig_types[965]
#define SWIGTYPE_p_p_Ogre__TransformKeyFrame swig_types[966]
#define SWIGTYPE_p_p_Ogre__VertexMorphKeyFrame swig_types[967]
#define SWIGTYPE_p_p_Ogre__VertexPoseKeyFrame swig_types[968]
#define SWIGTYPE_p_p_char swig_types[969]
#define SWIGTYPE_p_p_float swig_types[970]
#define SWIGTYPE_p_p_unsigned_char swig_types[971]
#define SWIGTYPE_p_p_unsigned_int swig_types[972]
#define SWIGTYPE_p_p_unsigned_short swig_types[973]
#define SWIGTYPE_p_p_void swig_types[974]
#define SWIGTYPE_p_reverse_iterator swig_types[975]
#define SWIGTYPE_p_short swig_types[976]
#define SWIGTYPE_p_size_t swig_types[977]
#define SWIGTYPE_p_size_type swig_types[978]
#define SWIGTYPE_p_std__basic_stringT_unsigned_int_t swig_types[979]
#define SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t swig_types[980]
#define SWIGTYPE_p_std__exception swig_types[981]
#define SWIGTYPE_p_std__fstream swig_types[982]
#define SWIGTYPE_p_std__ifstream swig_types[983]
#define SWIGTYPE_p_std__ios__fmtflags swig_types[984]
#define SWIGTYPE_p_std__ostream swig_types[985]
#define SWIGTYPE_p_std__pairT_Ogre__MovableObject_p_Ogre__MovableObject_p_t swig_types[986]
#define SWIGTYPE_p_std__pairT_Ogre__MovableObject_p_Ogre__WorldFragment_p_t swig_types[987]
#define SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t swig_types[988]
#define SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t swig_types[989]
#define SWIGTYPE_p_std__pairT_bool_Ogre__Vector3_t swig_types[990]
#define SWIGTYPE_p_std__pairT_bool_float_t swig_types[991]
#define SWIGTYPE_p_std__pairT_bool_std__string_t swig_types[992]
#define SWIGTYPE_p_std__pairT_size_t_size_t_t swig_types[993]
#define SWIGTYPE_p_std__pairT_unsigned_char_unsigned_char_t swig_types[994]
#define SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t swig_types[995]
#define SWIGTYPE_p_std__string swig_types[996]
#define SWIGTYPE_p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t swig_types[997]
#define SWIGTYPE_p_std__type_info swig_types[998]
#define SWIGTYPE_p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t swig_types[999]
#define SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t swig_types[1000]
#define SWIGTYPE_p_std__wostream swig_types[1001]
#define SWIGTYPE_p_std__wstring swig_types[1002]
#define SWIGTYPE_p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t swig_types[1003]
#define SWIGTYPE_p_swig__ConstIterator swig_types[1004]
#define SWIGTYPE_p_swig__GC_VALUE swig_types[1005]
#define SWIGTYPE_p_swig__Iterator swig_types[1006]
#define SWIGTYPE_p_time_t swig_types[1007]
#define SWIGTYPE_p_unicode_char swig_types[1008]
#define SWIGTYPE_p_unsigned_char swig_types[1009]
#define SWIGTYPE_p_unsigned_int swig_types[1010]
#define SWIGTYPE_p_unsigned_long swig_types[1011]
#define SWIGTYPE_p_unsigned_long_long swig_types[1012]
#define SWIGTYPE_p_unsigned_short swig_types[1013]
#define SWIGTYPE_p_utf32string swig_types[1014]
#define SWIGTYPE_p_value_type swig_types[1015]
#define SWIGTYPE_p_void swig_types[1016]
#define SWIGTYPE_p_wchar_t swig_types[1017]
#define SWIGTYPE_p_z_stream_s swig_types[1018]
#define SWIGTYPE_p_zzip_dir swig_types[1019]
#define SWIGTYPE_p_zzip_file swig_types[1020]
static swig_type_info *swig_types[1022];
static swig_module_info swig_module = {swig_types, 1021, 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_Ogre
#define SWIG_name    "Ogre"

static VALUE mOgre;

#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>


typedef int Intp;

SWIGINTERN Intp *new_Intp(){
    return (new int);
  }

#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


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;
}

SWIGINTERN void Intp_assign(Intp *self,int value){
    *self = value;
  }
SWIGINTERN int Intp_value(Intp *self){
    return *self;
  }

  #define SWIG_From_long   LONG2NUM 


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

SWIGINTERN int *Intp_cast(Intp *self){
    return self;
  }
SWIGINTERN Intp *Intp_frompointer(int *t){
    return (Intp *) t;
  }

#include <string>


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



#include <stdexcept>


#if defined(__GNUC__)
#  if __GNUC__ == 2 && __GNUC_MINOR <= 96
#     define SWIG_STD_NOMODERN_STL
#  endif
#endif


#include <string>
#include <stdexcept>
#include <stddef.h>


#include <utility>


#include <iostream>

  
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);
    }
  };

}


/*@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;
}


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_bool  (bool value)
{
  return value ? Qtrue : Qfalse;
}


SWIGINTERNINLINE int
SWIG_AsVal_ptrdiff_t (VALUE obj, ptrdiff_t *val)
{
  long v;
  int res = SWIG_AsVal_long (obj, val ? &v : 0);
  if (SWIG_IsOK(res) && val) *val = static_cast< ptrdiff_t >(v);
  return res;
}


SWIGINTERNINLINE VALUE
SWIG_From_ptrdiff_t  (ptrdiff_t value)
{    
  return SWIG_From_long  (static_cast< long >(value));
}


#include <stdexcept>


#include <algorithm>


#include <map>
#include <algorithm>
#include <stdexcept>


#include <vector>


#include <OgrePrerequisites.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;
}


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_FromCharPtr(const char *cptr)
{ 
  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
}


//	typedef Ogre::String String;


#include <OgreBuildSettings.h>




#include <OgreConfig.h>




#include <OgrePlatform.h>


#include <OgreVertexBoneAssignment.h>


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;
}


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


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_int  (unsigned int value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


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;
}


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_short  (unsigned short value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


#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;
}


  #define SWIG_From_double   rb_float_new 


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


#include <OgreAlignedAllocator.h>




#include <OgreMemoryAllocatedObject.h>




#include <OgreMemoryAllocatorConfig.h>



#include <OgreMath.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;
}


#include <OgreVector2.h>




#include <OgreQuaternion.h>


#include <OgreVector3.h>


#include <OgreVector4.h>




#include <OgreColourValue.h>


#include <OgreSharedPtr.h>


#include <OgreString.h>


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_From_std_string  (const std::string& s)
{
  return SWIG_FromCharPtrAndSize(s.data(), s.size());
}


#include <OgreStringVector.h>



#include <OgreHeaderPrefix.h>




#include <OgreException.h>







#include <OgreAny.h>
#include "AnyVALUE.h"

SWIGINTERN Ogre::AnyVALUE *Ogre_Any_toVALUE(Ogre::Any *self){
		return dynamic_cast<Ogre::AnyVALUE*>(self);
	}



#include <OgreAnimable.h>


#include <OgreIteratorRange.h>




#include <OgreIteratorWrapper.h>


#include <OgreIteratorWrappers.h>




#include <OgreMatrix3.h>




#include <OgrePlane.h>


#include <OgreMatrix4.h>


#include <OgreSimpleSpline.h>




#include <OgreRotationalSpline.h>




#include <OgreHardwareBuffer.h>


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


#include <OgreHardwareVertexBuffer.h>


#include <OgreKeyFrame.h>



typedef Ogre::VertexPoseKeyFrame::PoseRef PoseRef;
        


#include <OgrePose.h>


#include <OgreAnimationTrack.h>


#include <OgreController.h>




#include <OgreAnimationState.h>

SWIGINTERN void Ogre_AnimationStateSet_each_AnimationState(Ogre::AnimationStateSet *self){
		VALUE vstate = Qnil;
		Ogre::AnimationStateIterator iter = self->getAnimationStateIterator();
		while (iter.hasMoreElements()) {
			Ogre::AnimationState* state = iter.getNext();
			vstate = SWIG_NewPointerObj(SWIG_as_voidptr(state), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
			rb_yield_values(1, vstate);
		}
	}

#include <OgreAnimation.h>




#include <OgreDataStream.h>


#include <OgreArchive.h>


#include <OgreFactoryObj.h>




#include <OgreArchiveFactory.h>




#include <OgreAtomicWrappers.h>




#include <OgreCommon.h>


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

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


SWIGINTERNINLINE VALUE 
SWIG_From_long_SS_long  (long long value)
{
  return LL2NUM(value);
}


SWIGINTERNINLINE VALUE 
SWIG_From_unsigned_SS_long_SS_long  (unsigned long long value)
{
  return ULL2NUM(value);
}


#include <OgreStringInterface.h>




#include <OgreResource.h>


#include <OgreResourceGroupManager.h>


//	typedef Ogre::ResourceGroupManager::ResourceGroup ResourceGroup;
	typedef Ogre::ResourceGroupManager::ResourceDeclaration ResourceDeclaration;


#include <OgreScriptLoader.h>




#include <OgreResourceManager.h>



	typedef Ogre::ResourceManager::ResourcePool ResourcePool;


#include <OgreSingleton.h>




#include <OgreArchiveManager.h>




#include <OgreRenderQueue.h>


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;
}


SWIGINTERNINLINE VALUE
SWIG_From_unsigned_SS_char  (unsigned char value)
{    
  return SWIG_From_unsigned_SS_long  (value);
}


#include <OgreAxisAlignedBox.h>


#include <OgreSphere.h>




#include <OgreHardwareIndexBuffer.h>


#include <OgreVertexIndexData.h>




#include <OgreRenderOperation.h>




#include <OgreBlendMode.h>


#include <OgreMaterial.h>

SWIGINTERN Ogre::Material *Ogre_Material_cast(VALUE value){
		Ogre::Material* obj;
                Data_Get_Struct(value, Ogre::Material, obj);
                return obj;
	}

#include <OgreSerializer.h>


#include <OgreGpuProgramParams.h>


typedef Ogre::GpuProgramParameters::AutoConstantEntry  AutoConstantEntry;



#include <OgreGpuProgram.h>


#include <OgreUserObjectBindings.h>




#include <OgreRenderable.h>


#include <OgreShadowCaster.h>




#include <OgreMovableObject.h>


	typedef Ogre::MovableObject::ShadowRenderableListIterator ShadowRenderableListIterator;


#include <OgrePlaneBoundedVolume.h>


#include <OgreMovablePlane.h>




#include <OgreShadowCameraSetup.h>


#include <OgreLight.h>


#include <OgreAutoParamDataSource.h>




#include <OgreBillboard.h>




#include <OgreBillboardChain.h>


#include <OgreParticleSystemRenderer.h>




#include <OgreRadixSort.h>




#include <OgreBillboardSet.h>




#include <OgreBillboardParticleRenderer.h>




#include <OgreBitwise.h>




#include <OgreSkeleton.h>


#include <OgreMesh.h>


#include <OgreNode.h>


#include <OgreBone.h>




#include <OgreUTFString.h>


SWIGINTERN int
SWIG_AsCharArray(VALUE obj, char *val, size_t size)
{ 
  char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
  int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
  if (SWIG_IsOK(res)) {
    if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
    if (csize <= size) {
      if (val) {
	if (csize) memcpy(val, cptr, csize*sizeof(char));
	if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
      }
      if (alloc == SWIG_NEWOBJ) {
	delete[] cptr;
	res = SWIG_DelNewMask(res);
      }      
      return res;
    }
    if (alloc == SWIG_NEWOBJ) delete[] cptr;
  }
  return SWIG_TypeError;
}


SWIGINTERN int
SWIG_AsVal_char (VALUE obj, char *val)
{    
  int res = SWIG_AsCharArray(obj, val, 1);
  if (!SWIG_IsOK(res)) {
    long v;
    res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
    if (SWIG_IsOK(res)) {
      if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
	if (val) *val = static_cast< char >(v);
      } else {
	res = SWIG_OverflowError;
      }
    }
  }
  return res;
}


 static void debug_free_UTFString(void* ptr) {
	 Ogre::UTFString* string = (Ogre::UTFString*) ptr;
	 
	 std::cout << __PRETTY_FUNCTION__ << ": " << string->asUTF8_c_str() << std::endl;
	 
	 delete string;
 }


#include <OgreOverlayElementCommands.h>




#include <OgreRectangle.h>


#include <OgreOverlayElement.h>


#include <OgreOverlayContainer.h>

SWIGINTERN void Ogre_OverlayContainer_each_child(Ogre::OverlayContainer *self){
		VALUE vchild = Qnil;
                Ogre::OverlayContainer::ChildIterator iter = self->getChildIterator();
                while (iter.hasMoreElements()) {
                        Ogre::OverlayElement* child = iter.getNext();
                        vchild = SWIG_NewPointerObj(SWIG_as_voidptr(child), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
                        rb_yield_values(1, vchild);
                }

	}
SWIGINTERN void Ogre_OverlayContainer_each_child_container(Ogre::OverlayContainer *self){
		VALUE vchild = Qnil;
                Ogre::OverlayContainer::ChildContainerIterator iter = self->getChildContainerIterator();
                while (iter.hasMoreElements()) {
                        Ogre::OverlayContainer* child = iter.getNext();
                        vchild = SWIG_NewPointerObj(SWIG_as_voidptr(child), SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
                        rb_yield_values(1, vchild);
                }

	}
SWIGINTERN Ogre::OverlayContainer *Ogre_OverlayContainer_cast(VALUE value){
                Ogre::OverlayContainer* obj;
                Data_Get_Struct(value, Ogre::OverlayContainer, obj);
                return obj;
         }

#include <OgrePanelOverlayElement.h>

SWIGINTERN Ogre::PanelOverlayElement *Ogre_PanelOverlayElement_cast(VALUE value){
                Ogre::PanelOverlayElement* obj;
                Data_Get_Struct(value, Ogre::PanelOverlayElement, obj);
                return obj;
         }

#include <OgreBorderPanelOverlayElement.h>

SWIGINTERN Ogre::BorderPanelOverlayElement *Ogre_BorderPanelOverlayElement_cast(VALUE value){
		Ogre::BorderPanelOverlayElement* obj;
		Data_Get_Struct(value, Ogre::BorderPanelOverlayElement, obj);
		return obj;
	 }

#include <OgreFrustum.h>


#include <OgreRay.h>




#include <OgreCamera.h>


#include <OgreCodec.h>




#include <OgrePixelFormat.h>


#include <OgreImage.h>


#include <OgreTexture.h>


#include <OgreTextureUnitState.h>


#include <OgreMaterialSerializer.h>




#include <OgreMaterialManager.h>


#include <OgreStringConverter.h>




#include <OgreLog.h>




#include <OgreLogManager.h>




#include <OgreRenderSystemCapabilities.h>


#include <OgreTextureManager.h>


#include <OgreViewport.h>


#include <OgreTimer.h>




#include <OgreRenderTarget.h>


#include <OgreRenderTexture.h>




#include <OgreFrameListener.h>


#include <OgreConfigOptionMap.h>


#include <OgreRenderSystem.h>

SWIGINTERN VALUE Ogre_RenderSystem_getConfigOptionHash(Ogre::RenderSystem *self){
		VALUE hash = rb_hash_new();

		Ogre::ConfigOptionMap& options = self->getConfigOptions();
		for (Ogre::ConfigOptionMap::iterator it = options.begin(); it != options.end(); it++){
			//VALUE key = SWIG_From_std_string(static_cast< std::string >((it->first)));
			//std::string& s = static_cast< std::string >((it->first));
			VALUE key = SWIG_FromCharPtrAndSize(it->first.data(), it->first.size());
			VALUE value = SWIG_NewPointerObj(SWIG_as_voidptr(&(it->second)), SWIGTYPE_p_Ogre___ConfigOption, 0 |  0 );

			rb_hash_aset(hash, key, value);			
		}
		return hash;
	}

#include <OgreCompositionPass.h>




#include <OgreCompositionTargetPass.h>




#include <OgreCompositionTechnique.h>

namespace Ogre {
typedef Ogre::CompositionTechnique::TextureDefinition TextureDefinition;
}





#include <OgreCompositor.h>




#include <OgreRenderTargetListener.h>




#include <OgreRenderQueueListener.h>




#include <OgreCompositorInstance.h>




#include <OgreCompositorChain.h>




#include <OgreCompositorLogic.h>




#include <OgreRectangle2D.h>


#include <OgreCompositorManager.h>




#include <OgreConfigDialog.h>





#include <OgreConfigFile.h>


SWIGINTERN void Ogre_ConfigFile_each_Settings(Ogre::ConfigFile *self){
		Ogre::ConfigFile::SectionIterator seci = self->getSectionIterator();
		Ogre::String secName, typeName, archName;
		while (seci.hasMoreElements()) {
			secName = seci.peekNextKey();

			Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
			Ogre::ConfigFile::SettingsMultiMap::iterator i;
			for (i = settings->begin(); i != settings->end(); ++i) {
				typeName = i->first;
				archName = i->second;
				rb_yield_values(3,
						rb_str_new2(secName.c_str()),
						rb_str_new2(typeName.c_str()),
						rb_str_new2(archName.c_str()));
			}
		}
	}




#include <OgrePredefinedControllers.h>




#include <OgreControllerManager.h>




#include <OgrePolygon.h>




#include <OgreConvexBody.h>




#include <OgreCustomCompositionPass.h>




#include <OgreImageCodec.h>




#include <OgreDDSCodec.h>




#include <OgreRenderToVertexBuffer.h>




#include <OgreHardwareBufferManager.h>




#include <OgreDefaultHardwareBufferManager.h>




#include <OgreDeflate.h>




#include <OgreDepthBuffer.h>




#include <OgreLodStrategy.h>




#include <OgreDistanceLodStrategy.h>




#include <OgreDualQuaternion.h>




#include <OgreDynLib.h>




#include <OgreDynLibManager.h>




#include <OgreEdgeListBuilder.h>




#include <OgreEntity.h>


#include <OgreErrorDialog.h>




#include <OgreExternalTextureSource.h>




#include <OgreExternalTextureSourceManager.h>




#include <OgreFileSystem.h>




#include <OgreFont.h>




#include <OgreFontManager.h>




#include <OgreFreeImageCodec.h>




#include <OgreGpuProgramManager.h>




#include <OgreGpuProgramUsage.h>




#include <OgreHardwareOcclusionQuery.h>




#include <OgreHardwarePixelBuffer.h>


#include <OgreHeaderSuffix.h>




#include <OgreHighLevelGpuProgram.h>




#include <OgreHighLevelGpuProgramManager.h>




#include <OgreInstanceBatch.h>




#include <OgreInstanceBatchHW.h>




#include <OgreInstanceBatchVTF.h>




#include <OgreInstanceBatchHW_VTF.h>




#include <OgreInstanceBatchShader.h>




#include <OgreInstanceManager.h>




#include <OgreInstancedEntity.h>




#include <OgreSimpleRenderable.h>


#include <OgreSkeletonInstance.h>


#include <OgreInstancedGeometry.h>


#include <OgreLodListener.h>


#include <OgreLodStrategyManager.h>




#include <OgreManualObject.h>




#include <OgreMemoryNedAlloc.h>




#include <OgreMemoryNedPooling.h>


#include <OgreMemorySTLAllocator.h>



#include <OgreMemoryTracker.h>




#include <OgreMemoryStdAlloc.h>




#include <OgreMeshFileFormat.h>




#include <OgrePatchSurface.h>


#include <OgrePatchMesh.h>


#include <OgreMeshManager.h>


#include <OgreMeshSerializer.h>




#include <OgreOptimisedUtil.h>




#include <OgreOverlay.h>


#include <OgreTextAreaOverlayElement.h>




#include <OgreOverlayElementFactory.h>




#include <OgreOverlayManager.h>


 static void debug_free_OverlayManager(void* ptr) {
	 Ogre::OverlayManager* obj = (Ogre::OverlayManager*) ptr;
	 
	 std::cout << __PRETTY_FUNCTION__ << std::endl;
	 
	 delete obj;
 }


#include <OgreParticle.h>




#include <OgreParticleAffector.h>




#include <OgreParticleAffectorFactory.h>




#include <OgreParticleEmitterCommands.h>




#include <OgreParticleEmitter.h>




#include <OgreParticleEmitterFactory.h>




#include <OgreParticleIterator.h>




#include <OgreScriptCompiler.h>




#include <OgreParticleSystem.h>




#include <OgreParticleSystemManager.h>




#include <OgrePass.h>


#include <OgrePixelCountLodStrategy.h>




#include <OgrePlatformInformation.h>




#include <OgrePlugin.h>




#include <OgrePrefabFactory.h>




#include <OgreProfiler.h>




#include <OgreRenderObjectListener.h>




#include <OgreTechnique.h>



typedef Ogre::Technique::GPUVendorRule GPUVendorRule;
typedef Ogre::Technique::GPUDeviceNameRule GPUDeviceNameRule;

	


#include <OgreRenderQueueSortingGrouping.h>


#include <OgreRenderQueueInvocation.h>




#include <OgreRenderSystemCapabilitiesManager.h>




#include <OgreRenderSystemCapabilitiesSerializer.h>




#include <OgreRenderWindow.h>


#include <OgreWorkQueue.h>




#include <OgreResourceBackgroundQueue.h>




#include <OgreRibbonTrail.h>

SWIGINTERN Ogre::RibbonTrail *Ogre_RibbonTrail_cast(VALUE value){
                Ogre::RibbonTrail* obj;
                Data_Get_Struct(value, Ogre::RibbonTrail, obj);
                return obj;
         }

#include <OgreSceneNode.h>


#include <OgreSceneQuery.h>


#include <OgreShadowTextureManager.h>


#include <OgreSceneManager.h>

SWIGINTERN Ogre::MovableObject *Ogre_SceneManager_createMovableObject__SWIG_4(Ogre::SceneManager *self,Ogre::String const &name,Ogre::String const &typeName,VALUE params){
		puts("createMovableObject");
		return NULL;
	}
SWIGINTERN Ogre::MovableObject *Ogre_SceneManager_createMovableObject__SWIG_5(Ogre::SceneManager *self,Ogre::String const &typeName,VALUE params){
		Ogre::NameValuePairList pairList;
		VALUE newParams = rb_hash_dup(params);
		while (!RHASH_EMPTY_P(newParams)) {
			VALUE pair = rb_funcall(newParams, rb_intern("shift"), 0);
			VALUE key   = RARRAY_PTR(pair)[0];
			VALUE value = RARRAY_PTR(pair)[1];
			pairList[StringValuePtr(key)] = StringValuePtr(value);
		}

		return self->createMovableObject(typeName, &pairList);
	}

	typedef Ogre::SceneManagerFactory SceneManagerFactory;
	typedef Ogre::SceneManagerMetaData SceneManagerMetaData;
	typedef Ogre::SceneManager::RenderContext RenderContext;
	typedef Ogre::SceneManager::SkyPlaneGenParameters SkyPlaneGenParameters;
	typedef Ogre::SceneManager::SkyBoxGenParameters SkyBoxGenParameters;
	typedef Ogre::SceneManager::SkyDomeGenParameters SkyDomeGenParameters;
	typedef Ogre::SceneManager::SceneMgrQueuedRenderableVisitor SceneMgrQueuedRenderableVisitor;


#include <OgreRoot.h>

SWIGINTERN VALUE Ogre_Root_getAvailableRendererArray(Ogre::Root *self){
		VALUE ary = rb_ary_new();

		Ogre::RenderSystemList rsList = self->getAvailableRenderers();
		for (unsigned int i = 0; i < rsList.size(); i++) {
			VALUE rs = SWIG_NewPointerObj(SWIG_as_voidptr(rsList[i]), SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
			rb_ary_push(ary, rs);
		}
		return ary;
	}
SWIGINTERN void Ogre_Root_destruct(Ogre::Root *self){
		delete self;
		self = NULL;
	}

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


#include <OgreSceneManagerEnumerator.h>


#include <OgreScriptLexer.h>




#include <OgreScriptParser.h>




#include <OgreScriptTranslator.h>




#include <OgreShadowCameraSetupFocused.h>




#include <OgreShadowCameraSetupLiSPSM.h>




#include <OgreShadowCameraSetupPSSM.h>




#include <OgreShadowCameraSetupPlaneOptimal.h>




#include <OgreShadowVolumeExtrudeProgram.h>




#include <OgreSkeletonFileFormat.h>




#include <OgreSkeletonManager.h>




#include <OgreSkeletonSerializer.h>




#include <OgreSpotShadowFadePng.h>




#include <OgreStableHeaders.h>




#include <OgreStaticFaceGroup.h>




#include <OgreStaticGeometry.h>

namespace Ogre {
	typedef Ogre::StaticGeometry::Region Region;
}





#include <OgreStaticPluginLoader.h>




#include <OgreStdHeaders.h>




#include <OgreStreamSerialiser.h>




#include <OgreSubEntity.h>




#include <OgreSubMesh.h>




#include <OgreTagPoint.h>




#include <OgreTangentSpaceCalc.h>




#include <OgreUnifiedHighLevelGpuProgram.h>




#include <OgreWindowEventUtilities.h>


#include <OgreWireBoundingBox.h>




#include <OgreZip.h>




#include <Ogre.h>




#include <OgrePagingPrerequisites.h>




#include <OgrePageStrategy.h>




#include <OgreGrid2DPageStrategy.h>




#include <OgreGrid3DPageStrategy.h>




#include <OgrePage.h>




#include <OgrePageConnection.h>




#include <OgrePageContent.h>




#include <OgrePageContentCollection.h>




#include <OgrePageContentCollectionFactory.h>




#include <OgrePageContentFactory.h>




#include <OgrePageFileFormats.h>




#include <OgrePageManager.h>




#include <OgrePagedWorld.h>




#include <OgrePagedWorldSection.h>




#include <OgreSimplePageContentCollection.h>




#include <OgrePaging.h>




#include <OgreTerrainPrerequisites.h>




#include <OgreTerrainGroup.h>


SWIGINTERN void Ogre_TerrainGroup_setDefaultImportSettings(Ogre::TerrainGroup *self,float y){
		Ogre::Terrain::ImportData& defaultimp = self->getDefaultImportSettings();
		defaultimp.terrainSize = 513;
		defaultimp.pos.y = y;
		defaultimp.worldSize = 12000.0f;
		defaultimp.inputScale = 600;
		defaultimp.minBatchSize = 33;
		defaultimp.maxBatchSize = 65;
		// textures
		defaultimp.layerList.resize(3);
		defaultimp.layerList[0].worldSize = 100;
		defaultimp.layerList[0].textureNames.push_back("dirt_grayrocky_diffusespecular.dds");
		defaultimp.layerList[0].textureNames.push_back("dirt_grayrocky_normalheight.dds");
		defaultimp.layerList[1].worldSize = 30;
		defaultimp.layerList[1].textureNames.push_back("grass_green-01_diffusespecular.dds");
		defaultimp.layerList[1].textureNames.push_back("grass_green-01_normalheight.dds");
		defaultimp.layerList[2].worldSize = 200;
		defaultimp.layerList[2].textureNames.push_back("growth_weirdfungus-03_diffusespecular.dds");
		defaultimp.layerList[2].textureNames.push_back("growth_weirdfungus-03_normalheight.dds");		
	}
SWIGINTERN void Ogre_TerrainGroup_initBlendMaps(Ogre::TerrainGroup *self){
		Ogre::TerrainGroup::TerrainIterator ti = self->getTerrainIterator();
		while(ti.hasMoreElements())
		{
			Ogre::Terrain* terrain = ti.getNext()->instance;

			Ogre::TerrainLayerBlendMap* blendMap0 = terrain->getLayerBlendMap(1);
			Ogre::TerrainLayerBlendMap* blendMap1 = terrain->getLayerBlendMap(2);
			Ogre::Real minHeight0 = 70;
			Ogre::Real fadeDist0 = 40;
			Ogre::Real minHeight1 = 70;
			Ogre::Real fadeDist1 = 15;
			float* pBlend0 = blendMap0->getBlendPointer();
			float* pBlend1 = blendMap1->getBlendPointer();
			for (Ogre::uint16 y = 0; y < terrain->getLayerBlendMapSize(); ++y)
			{
				for (Ogre::uint16 x = 0; x < terrain->getLayerBlendMapSize(); ++x)
				{
					Ogre::Real tx, ty;
					
					blendMap0->convertImageToTerrainSpace(x, y, &tx, &ty);
					Ogre::Real height = terrain->getHeightAtTerrainPosition(tx, ty);
					Ogre::Real val = (height - minHeight0) / fadeDist0;
					val = Ogre::Math::Clamp(val, (Ogre::Real)0, (Ogre::Real)1);
					*pBlend0++ = val;
					
					val = (height - minHeight1) / fadeDist1;
					val = Ogre::Math::Clamp(val, (Ogre::Real)0, (Ogre::Real)1);
					*pBlend1++ = val;
				}
			}
			blendMap0->dirty();
			blendMap1->dirty();
			blendMap0->update();
			blendMap1->update();
		}
	}

typedef Ogre::TerrainGroup::TerrainSlot TerrainSlot;


#include <OgreTerrainLayerBlendMap.h>




#include <OgreTerrainMaterialGenerator.h>




#include <OgreTerrainMaterialGeneratorA.h>




#include <OgreTerrainPagedWorldSection.h>




#include <OgreTerrainPaging.h>




#include <OgreTerrainQuadTreeNode.h>




#include <OgreTerrain.h>


typedef Ogre::Terrain::LayerInstance LayerInstance;
typedef Ogre::Terrain::ImportData ImportData;

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



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

#include "ogre_wrap.h"

SwigDirector_FrameListener::SwigDirector_FrameListener(VALUE self): Ogre::FrameListener(), Swig::Director(self) {
  
}



bool SwigDirector_FrameListener::frameStarted(Ogre::FrameEvent const &evt) {
  bool c_result ;
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__FrameEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("frameStarted"), 1,obj0);
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_FrameListener::frameRenderingQueued(Ogre::FrameEvent const &evt) {
  bool c_result ;
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__FrameEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("frameRenderingQueued"), 1,obj0);
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


bool SwigDirector_FrameListener::frameEnded(Ogre::FrameEvent const &evt) {
  bool c_result ;
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__FrameEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("frameEnded"), 1,obj0);
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


SwigDirector_FrameListener::~SwigDirector_FrameListener() {
}

SwigDirector_RenderTargetListener::SwigDirector_RenderTargetListener(VALUE self): Ogre::RenderTargetListener(), Swig::Director(self) {
  
}



SwigDirector_RenderTargetListener::~SwigDirector_RenderTargetListener() {
}

void SwigDirector_RenderTargetListener::preRenderTargetUpdate(Ogre::RenderTargetEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__RenderTargetEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("preRenderTargetUpdate"), 1,obj0);
}


void SwigDirector_RenderTargetListener::postRenderTargetUpdate(Ogre::RenderTargetEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__RenderTargetEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("postRenderTargetUpdate"), 1,obj0);
}


void SwigDirector_RenderTargetListener::preViewportUpdate(Ogre::RenderTargetViewportEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("preViewportUpdate"), 1,obj0);
}


void SwigDirector_RenderTargetListener::postViewportUpdate(Ogre::RenderTargetViewportEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("postViewportUpdate"), 1,obj0);
}


void SwigDirector_RenderTargetListener::viewportAdded(Ogre::RenderTargetViewportEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("viewportAdded"), 1,obj0);
}


void SwigDirector_RenderTargetListener::viewportRemoved(Ogre::RenderTargetViewportEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("viewportRemoved"), 1,obj0);
}


SwigDirector_RenderQueueListener::SwigDirector_RenderQueueListener(VALUE self): Ogre::RenderQueueListener(), Swig::Director(self) {
  
}



SwigDirector_RenderQueueListener::~SwigDirector_RenderQueueListener() {
}

void SwigDirector_RenderQueueListener::preRenderQueues() {
  VALUE result;
  
  result = rb_funcall(swig_get_self(), rb_intern("preRenderQueues"), 0, NULL);
}


void SwigDirector_RenderQueueListener::postRenderQueues() {
  VALUE result;
  
  result = rb_funcall(swig_get_self(), rb_intern("postRenderQueues"), 0, NULL);
}


void SwigDirector_RenderQueueListener::renderQueueStarted(Ogre::uint8 queueGroupId, Ogre::String const &invocation, bool &skipThisInvocation) {
  VALUE obj0 = Qnil ;
  VALUE obj1 = Qnil ;
  VALUE obj2 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(queueGroupId));
  obj1 = SWIG_From_std_string(static_cast< std::string >(invocation));
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&skipThisInvocation), SWIGTYPE_p_bool,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("renderQueueStarted"), 3,obj0,obj1,obj2);
}


void SwigDirector_RenderQueueListener::renderQueueEnded(Ogre::uint8 queueGroupId, Ogre::String const &invocation, bool &repeatThisInvocation) {
  VALUE obj0 = Qnil ;
  VALUE obj1 = Qnil ;
  VALUE obj2 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(queueGroupId));
  obj1 = SWIG_From_std_string(static_cast< std::string >(invocation));
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(&repeatThisInvocation), SWIGTYPE_p_bool,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("renderQueueEnded"), 3,obj0,obj1,obj2);
}


SwigDirector_LodListener::SwigDirector_LodListener(VALUE self): Ogre::LodListener(), Swig::Director(self) {
  
}



SwigDirector_LodListener::~SwigDirector_LodListener() {
}

bool SwigDirector_LodListener::prequeueMovableObjectLodChanged(Ogre::MovableObjectLodChangedEvent const &evt) {
  bool c_result ;
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__MovableObjectLodChangedEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("prequeueMovableObjectLodChanged"), 1,obj0);
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_LodListener::postqueueMovableObjectLodChanged(Ogre::MovableObjectLodChangedEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__MovableObjectLodChangedEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("postqueueMovableObjectLodChanged"), 1,obj0);
}


bool SwigDirector_LodListener::prequeueEntityMeshLodChanged(Ogre::EntityMeshLodChangedEvent &evt) {
  bool c_result ;
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__EntityMeshLodChangedEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("prequeueEntityMeshLodChanged"), 1,obj0);
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_LodListener::postqueueEntityMeshLodChanged(Ogre::EntityMeshLodChangedEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__EntityMeshLodChangedEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("postqueueEntityMeshLodChanged"), 1,obj0);
}


bool SwigDirector_LodListener::prequeueEntityMaterialLodChanged(Ogre::EntityMaterialLodChangedEvent &evt) {
  bool c_result ;
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__EntityMaterialLodChangedEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("prequeueEntityMaterialLodChanged"), 1,obj0);
  bool swig_val;
  int swig_res = SWIG_AsVal_bool(result, &swig_val);
  if (!SWIG_IsOK(swig_res)) {
    Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(SWIG_ArgError(swig_res)), "in output value of type '""bool""'");
  }
  c_result = static_cast< bool >(swig_val);
  return (bool) c_result;
}


void SwigDirector_LodListener::postqueueEntityMaterialLodChanged(Ogre::EntityMaterialLodChangedEvent const &evt) {
  VALUE obj0 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(&evt), SWIGTYPE_p_Ogre__EntityMaterialLodChangedEvent,  0 );
  result = rb_funcall(swig_get_self(), rb_intern("postqueueEntityMaterialLodChanged"), 1,obj0);
}


SwigDirector_RenderObjectListener::SwigDirector_RenderObjectListener(VALUE self): Ogre::RenderObjectListener(), Swig::Director(self) {
  
}



SwigDirector_RenderObjectListener::~SwigDirector_RenderObjectListener() {
}

void SwigDirector_RenderObjectListener::notifyRenderSingleObject(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::AutoParamDataSource const *source, Ogre::LightList const *pLightList, bool suppressRenderStateChanges) {
  VALUE obj0 = Qnil ;
  VALUE obj1 = Qnil ;
  VALUE obj2 = Qnil ;
  VALUE obj3 = Qnil ;
  VALUE obj4 = Qnil ;
  VALUE result;
  
  obj0 = SWIG_NewPointerObj(SWIG_as_voidptr(rend), SWIGTYPE_p_Ogre__Renderable,  0 );
  obj1 = SWIG_NewPointerObj(SWIG_as_voidptr(pass), SWIGTYPE_p_Ogre__Pass,  0 );
  obj2 = SWIG_NewPointerObj(SWIG_as_voidptr(source), SWIGTYPE_p_Ogre__AutoParamDataSource,  0 );
  obj3 = SWIG_NewPointerObj(SWIG_as_voidptr(pLightList), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  obj4 = SWIG_From_bool(static_cast< bool >(suppressRenderStateChanges));
  result = rb_funcall(swig_get_self(), rb_intern("notifyRenderSingleObject"), 5,obj0,obj1,obj2,obj3,obj4);
}


swig_class SwigClassIntp;

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

SWIGINTERN VALUE
_wrap_new_Intp(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Intp";
  Intp *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Intp *)new_Intp();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void delete_Intp(Intp *self){
    if (self) delete self;
  }
SWIGINTERN void
free_Intp(Intp *arg1) {
    delete_Intp(arg1);
}

SWIGINTERN VALUE
_wrap_Intp_assign(int argc, VALUE *argv, VALUE self) {
  Intp *arg1 = (Intp *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Intp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Intp *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Intp * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","assign", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  Intp_assign(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Intp_value(int argc, VALUE *argv, VALUE self) {
  Intp *arg1 = (Intp *) 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_Intp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Intp *","value", 1, self )); 
  }
  arg1 = reinterpret_cast< Intp * >(argp1);
  result = (int)Intp_value(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Intp_cast(int argc, VALUE *argv, VALUE self) {
  Intp *arg1 = (Intp *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Intp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Intp *","cast", 1, self )); 
  }
  arg1 = reinterpret_cast< Intp * >(argp1);
  result = (int *)Intp_cast(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Intp_frompointer(int argc, VALUE *argv, VALUE self) {
  int *arg1 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Intp *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(argv[0], &argp1,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int *","Intp_frompointer", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< int * >(argp1);
  result = (Intp *)Intp_frompointer(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Intp, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassGC_VALUE;


/*
  Document-method: Ogre::GC_VALUE.inspect

  call-seq:
    inspect -> VALUE

Inspect class and its contents.
*/
SWIGINTERN VALUE
_wrap_GC_VALUE_inspect(int argc, VALUE *argv, VALUE self) {
  swig::GC_VALUE *arg1 = (swig::GC_VALUE *) 0 ;
  swig::GC_VALUE r1 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  r1 = self; arg1 = &r1;
  result = (VALUE)((swig::GC_VALUE const *)arg1)->inspect();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::GC_VALUE.to_s

  call-seq:
    to_s -> VALUE

Convert class to a String representation.
*/
SWIGINTERN VALUE
_wrap_GC_VALUE_to_s(int argc, VALUE *argv, VALUE self) {
  swig::GC_VALUE *arg1 = (swig::GC_VALUE *) 0 ;
  swig::GC_VALUE r1 ;
  VALUE result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  r1 = self; arg1 = &r1;
  result = (VALUE)((swig::GC_VALUE const *)arg1)->to_s();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassConstIterator;

SWIGINTERN void
free_swig_ConstIterator(swig::ConstIterator *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ConstIterator_value(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","value", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  try {
    result = (VALUE)((swig::ConstIterator const *)arg1)->value();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConstIterator.dup

  call-seq:
    dup -> ConstIterator

Create a duplicate of the class and unfreeze it if needed.
*/
SWIGINTERN VALUE
_wrap_ConstIterator_dup(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","dup", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->dup();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConstIterator.inspect

  call-seq:
    inspect -> VALUE

Inspect class and its contents.
*/
SWIGINTERN VALUE
_wrap_ConstIterator_inspect(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  result = (VALUE)((swig::ConstIterator const *)arg1)->inspect();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConstIterator.to_s

  call-seq:
    to_s -> VALUE

Convert class to a String representation.
*/
SWIGINTERN VALUE
_wrap_ConstIterator_to_s(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","to_s", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  result = (VALUE)((swig::ConstIterator const *)arg1)->to_s();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConstIterator_next__SWIG_0(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","next", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (swig::ConstIterator *)(arg1)->next(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConstIterator_next__SWIG_1(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  try {
    result = (swig::ConstIterator *)(arg1)->next();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConstIterator_next(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_swig__ConstIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ConstIterator_next__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConstIterator_next__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ConstIterator.next", 
    "    swig::ConstIterator * ConstIterator.next(size_t n)\n"
    "    swig::ConstIterator * ConstIterator.next()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConstIterator_previous__SWIG_0(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","previous", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","previous", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (swig::ConstIterator *)(arg1)->previous(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConstIterator_previous__SWIG_1(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator *","previous", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  try {
    result = (swig::ConstIterator *)(arg1)->previous();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConstIterator_previous(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_swig__ConstIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ConstIterator_previous__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConstIterator_previous__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ConstIterator.previous", 
    "    swig::ConstIterator * ConstIterator.previous(size_t n)\n"
    "    swig::ConstIterator * ConstIterator.previous()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ConstIterator.==

  call-seq:
    ==(x) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_ConstIterator___eq__(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__ConstIterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::ConstIterator const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::ConstIterator const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< swig::ConstIterator * >(argp2);
  result = (bool)((swig::ConstIterator const *)arg1)->operator ==((swig::ConstIterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConstIterator.+

  call-seq:
    +(n) -> ConstIterator

Add operator.
*/
SWIGINTERN VALUE
_wrap_ConstIterator___add__(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator +", 2, argv[0] ));
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator +(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConstIterator.-

  call-seq:
    -(n) -> ConstIterator
    -(x) -> ptrdiff_t

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_ConstIterator___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::ConstIterator *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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator -", 2, argv[0] ));
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::ConstIterator *)((swig::ConstIterator const *)arg1)->operator -(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__ConstIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConstIterator___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
  swig::ConstIterator *arg1 = (swig::ConstIterator *) 0 ;
  swig::ConstIterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t 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_swig__ConstIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::ConstIterator const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::ConstIterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__ConstIterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::ConstIterator const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::ConstIterator const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< swig::ConstIterator * >(argp2);
  result = ((swig::ConstIterator const *)arg1)->operator -((swig::ConstIterator const &)*arg2);
  vresult = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConstIterator___sub__(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_swig__ConstIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConstIterator___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__ConstIterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ConstIterator___sub____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__sub__.new", 
    "    __sub__.new(ptrdiff_t n)\n"
    "    __sub__.new(swig::ConstIterator const &x)\n");
  
  return Qnil;
}


swig_class SwigClassIterator;

SWIGINTERN VALUE
_wrap_Iterator_valuee___(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  VALUE *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE temp2 ;
  VALUE 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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  temp2 = static_cast< VALUE >(argv[0]);
  arg2 = &temp2;
  result = (VALUE)(arg1)->setValue((VALUE const &)*arg2);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Iterator.dup

  call-seq:
    dup -> Iterator

Create a duplicate of the class and unfreeze it if needed.
*/
SWIGINTERN VALUE
_wrap_Iterator_dup(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","dup", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  result = (swig::Iterator *)((swig::Iterator const *)arg1)->dup();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Iterator_next__SWIG_0(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","next", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (swig::Iterator *)(arg1)->next(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Iterator_next__SWIG_1(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","next", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  try {
    result = (swig::Iterator *)(arg1)->next();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Iterator_next(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_swig__Iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Iterator_next__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Iterator_next__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Iterator.next", 
    "    swig::Iterator * Iterator.next(size_t n)\n"
    "    swig::Iterator * Iterator.next()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Iterator_previous__SWIG_0(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","previous", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","previous", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (swig::Iterator *)(arg1)->previous(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Iterator_previous__SWIG_1(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator *","previous", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  try {
    result = (swig::Iterator *)(arg1)->previous();
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Iterator_previous(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_swig__Iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Iterator_previous__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Iterator_previous__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Iterator.previous", 
    "    swig::Iterator * Iterator.previous(size_t n)\n"
    "    swig::Iterator * Iterator.previous()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Iterator.inspect

  call-seq:
    inspect -> VALUE

Inspect class and its contents.
*/
SWIGINTERN VALUE
_wrap_Iterator_inspect(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","inspect", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  result = (VALUE)((swig::Iterator const *)arg1)->inspect();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Iterator.to_s

  call-seq:
    to_s -> VALUE

Convert class to a String representation.
*/
SWIGINTERN VALUE
_wrap_Iterator_to_s(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","to_s", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  result = (VALUE)((swig::Iterator const *)arg1)->to_s();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Iterator.==

  call-seq:
    ==(x) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Iterator___eq__(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__Iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::Iterator const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::Iterator const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< swig::Iterator * >(argp2);
  result = (bool)((swig::Iterator const *)arg1)->operator ==((swig::Iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Iterator.+

  call-seq:
    +(n) -> Iterator

Add operator.
*/
SWIGINTERN VALUE
_wrap_Iterator___add__(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator +", 2, argv[0] ));
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator +(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Iterator.-

  call-seq:
    -(n) -> Iterator
    -(x) -> ptrdiff_t

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Iterator___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  ptrdiff_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  ptrdiff_t val2 ;
  int ecode2 = 0 ;
  swig::Iterator *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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  ecode2 = SWIG_AsVal_ptrdiff_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "ptrdiff_t","operator -", 2, argv[0] ));
  } 
  arg2 = static_cast< ptrdiff_t >(val2);
  try {
    result = (swig::Iterator *)((swig::Iterator const *)arg1)->operator -(arg2);
  }
  catch(swig::stop_iteration &_e) {
    {
      (void)_e;
      SWIG_Ruby_ExceptionType(NULL, Qnil);
      SWIG_fail;
    }
  }
  
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_swig__Iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Iterator___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
  swig::Iterator *arg1 = (swig::Iterator *) 0 ;
  swig::Iterator *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  ptrdiff_t 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_swig__Iterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "swig::Iterator const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< swig::Iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_swig__Iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "swig::Iterator const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "swig::Iterator const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< swig::Iterator * >(argp2);
  result = ((swig::Iterator const *)arg1)->operator -((swig::Iterator const &)*arg2);
  vresult = SWIG_From_ptrdiff_t(static_cast< ptrdiff_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Iterator___sub__(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_swig__Iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_swig__Iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Iterator___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_swig__Iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_ptrdiff_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Iterator___sub____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "__sub__.new", 
    "    __sub__.new(ptrdiff_t n)\n"
    "    __sub__.new(swig::Iterator const &x)\n");
  
  return Qnil;
}


SWIGINTERN void
free_swig_Iterator(swig::Iterator *arg1) {
    delete arg1;
}

swig_class SwigClassVertexBoneAssignment;

SWIGINTERN VALUE
_wrap_VertexBoneAssignment_vertexIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBoneAssignment *arg1 = (Ogre::VertexBoneAssignment *) 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_Ogre__VertexBoneAssignment_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment *","vertexIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBoneAssignment * >(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","vertexIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->vertexIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBoneAssignment_vertexIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBoneAssignment *arg1 = (Ogre::VertexBoneAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__VertexBoneAssignment_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment *","vertexIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBoneAssignment * >(argp1);
  result = (unsigned int) ((arg1)->vertexIndex);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBoneAssignment_boneIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBoneAssignment *arg1 = (Ogre::VertexBoneAssignment *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexBoneAssignment_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment *","boneIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBoneAssignment * >(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","boneIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  if (arg1) (arg1)->boneIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBoneAssignment_boneIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBoneAssignment *arg1 = (Ogre::VertexBoneAssignment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexBoneAssignment_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment *","boneIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBoneAssignment * >(argp1);
  result = (unsigned short) ((arg1)->boneIndex);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBoneAssignment_weight_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBoneAssignment *arg1 = (Ogre::VertexBoneAssignment *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__VertexBoneAssignment_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment *","weight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBoneAssignment * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","weight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->weight = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBoneAssignment_weight_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBoneAssignment *arg1 = (Ogre::VertexBoneAssignment *) 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_Ogre__VertexBoneAssignment_s, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment *","weight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBoneAssignment * >(argp1);
  result = (Ogre::Real) ((arg1)->weight);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VertexBoneAssignment(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::VertexBoneAssignment";
  Ogre::VertexBoneAssignment *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VertexBoneAssignment *)new Ogre::VertexBoneAssignment();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexBoneAssignment(Ogre::VertexBoneAssignment *arg1) {
    delete arg1;
}

swig_class SwigClassAlignedMemory;

SWIGINTERN VALUE
_wrap_AlignedMemory_deallocate(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::AlignedMemory::deallocate", 1, argv[0] )); 
  }
  Ogre::AlignedMemory::deallocate(arg1);
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_AlignedMemory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::AlignedMemory";
  Ogre::AlignedMemory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::AlignedMemory *)new Ogre::AlignedMemory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AlignedMemory(Ogre::AlignedMemory *arg1) {
    delete arg1;
}

swig_class SwigClassRadian;

SWIGINTERN VALUE
_wrap_new_Radian__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Radian";
  Ogre::Radian *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","Ogre::Radian", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Radian *)new Ogre::Radian(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Radian__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Radian";
  Ogre::Radian *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Radian *)new Ogre::Radian();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Radian__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Radian";
  Ogre::Radian *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__Degree,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const &","Ogre::Radian", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","Ogre::Radian", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = (Ogre::Radian *)new Ogre::Radian((Ogre::Degree const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Radian(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_Radian__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Radian__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_Radian__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Radian.new", 
    "    Radian.new(Ogre::Real r)\n"
    "    Radian.new()\n"
    "    Radian.new(Ogre::Degree const &d)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Radian_valueDegrees(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","valueDegrees", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Real)((Ogre::Radian const *)arg1)->valueDegrees();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Radian_valueRadians(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","valueRadians", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Real)((Ogre::Radian const *)arg1)->valueRadians();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Radian_valueAngleUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","valueAngleUnits", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Real)((Ogre::Radian const *)arg1)->valueAngleUnits();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Radian.+@

  call-seq:
    +@ -> Radian

Add operator.
*/
SWIGINTERN VALUE
_wrap_Radian___pos__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Radian *) &((Ogre::Radian const *)arg1)->operator +();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Radian.+

  call-seq:
    +(r) -> Radian
    +(d) -> Radian

Add operator.
*/
SWIGINTERN VALUE
_wrap_Radian___add____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = ((Ogre::Radian const *)arg1)->operator +((Ogre::Radian const &)*arg2);
  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_Radian___add____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Degree *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = ((Ogre::Radian const *)arg1)->operator +((Ogre::Degree const &)*arg2);
  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_Radian___add__(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_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Radian___add____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Radian___add____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Radian.__add__", 
    "    Ogre::Radian Radian.__add__(Ogre::Radian const &r)\n"
    "    Ogre::Radian Radian.__add__(Ogre::Degree const &d)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Radian.-@

  call-seq:
    -@ -> Radian

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Radian___neg__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = ((Ogre::Radian const *)arg1)->operator -();
  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;
}



/*
  Document-method: Ogre::Radian.-

  call-seq:
    -(r) -> Radian
    -(d) -> Radian

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Radian___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = ((Ogre::Radian const *)arg1)->operator -((Ogre::Radian const &)*arg2);
  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_Radian___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Degree *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = ((Ogre::Radian const *)arg1)->operator -((Ogre::Degree const &)*arg2);
  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_Radian___sub__(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_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Radian___sub____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Radian___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Radian.__sub__", 
    "    Ogre::Radian Radian.__sub__(Ogre::Radian const &r)\n"
    "    Ogre::Radian Radian.__sub__(Ogre::Degree const &d)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Radian___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Radian const *)arg1)->operator *(arg2);
  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_Radian___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = ((Ogre::Radian const *)arg1)->operator *((Ogre::Radian const &)*arg2);
  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_Radian___mul__(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_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Radian___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Radian___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Radian.__mul__", 
    "    Ogre::Radian Radian.__mul__(Ogre::Real f)\n"
    "    Ogre::Radian Radian.__mul__(Ogre::Radian const &f)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Radian___div__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Radian 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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Radian const *)arg1)->operator /(arg2);
  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;
}



/*
  Document-method: Ogre::Radian.<

  call-seq:
    <(r) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Radian___lt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = (bool)((Ogre::Radian const *)arg1)->operator <((Ogre::Radian const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Radian.<=

  call-seq:
    <=(r) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_Radian___le__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator <=", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator <=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator <=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = (bool)((Ogre::Radian const *)arg1)->operator <=((Ogre::Radian const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Radian.==

  call-seq:
    ==(r) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Radian___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = (bool)((Ogre::Radian const *)arg1)->operator ==((Ogre::Radian const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Radian.>=

  call-seq:
    >=(r) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_Radian___ge__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator >=", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator >=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator >=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = (bool)((Ogre::Radian const *)arg1)->operator >=((Ogre::Radian const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Radian.>

  call-seq:
    >(r) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Radian___gt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = (Ogre::Radian *) 0 ;
  Ogre::Radian *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_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const *","operator >", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 const &","operator >", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator >", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = (bool)((Ogre::Radian const *)arg1)->operator >((Ogre::Radian const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Radian(Ogre::Radian *arg1) {
    delete arg1;
}

swig_class SwigClassDegree;

SWIGINTERN VALUE
_wrap_new_Degree__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Degree";
  Ogre::Degree *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","Ogre::Degree", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Degree *)new Ogre::Degree(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Degree__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Degree";
  Ogre::Degree *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Degree *)new Ogre::Degree();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Degree__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Degree";
  Ogre::Degree *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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Degree", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Degree", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Degree *)new Ogre::Degree((Ogre::Radian const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Degree(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_Degree__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Degree__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_Degree__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Degree.new", 
    "    Degree.new(Ogre::Real d)\n"
    "    Degree.new()\n"
    "    Degree.new(Ogre::Radian const &r)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree_valueDegrees(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","valueDegrees", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = (Ogre::Real)((Ogre::Degree const *)arg1)->valueDegrees();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree_valueRadians(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","valueRadians", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = (Ogre::Real)((Ogre::Degree const *)arg1)->valueRadians();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree_valueAngleUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","valueAngleUnits", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = (Ogre::Real)((Ogre::Degree const *)arg1)->valueAngleUnits();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.+@

  call-seq:
    +@ -> Degree

Add operator.
*/
SWIGINTERN VALUE
_wrap_Degree___pos__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Degree *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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = (Ogre::Degree *) &((Ogre::Degree const *)arg1)->operator +();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Degree, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.+

  call-seq:
    +(d) -> Degree
    +(r) -> Degree

Add operator.
*/
SWIGINTERN VALUE
_wrap_Degree___add____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = ((Ogre::Degree const *)arg1)->operator +((Ogre::Degree const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree___add____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(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 const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = ((Ogre::Degree const *)arg1)->operator +((Ogre::Radian const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Degree___add__(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_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Degree___add____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Degree___add____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Degree.__add__", 
    "    Ogre::Degree Degree.__add__(Ogre::Degree const &d)\n"
    "    Ogre::Degree Degree.__add__(Ogre::Radian const &r)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Degree.-@

  call-seq:
    -@ -> Degree

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Degree___neg__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = ((Ogre::Degree const *)arg1)->operator -();
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.-

  call-seq:
    -(d) -> Degree
    -(r) -> Degree

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Degree___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = ((Ogre::Degree const *)arg1)->operator -((Ogre::Degree const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(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 const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = ((Ogre::Degree const *)arg1)->operator -((Ogre::Radian const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Degree___sub__(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_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Degree___sub____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Degree___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Degree.__sub__", 
    "    Ogre::Degree Degree.__sub__(Ogre::Degree const &d)\n"
    "    Ogre::Degree Degree.__sub__(Ogre::Radian const &r)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Degree const *)arg1)->operator *(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = ((Ogre::Degree const *)arg1)->operator *((Ogre::Degree const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Degree___mul__(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_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Degree___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Degree___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Degree.__mul__", 
    "    Ogre::Degree Degree.__mul__(Ogre::Real f)\n"
    "    Ogre::Degree Degree.__mul__(Ogre::Degree const &f)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Degree___div__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Degree 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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Degree const *)arg1)->operator /(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.<

  call-seq:
    <(d) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Degree___lt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = (bool)((Ogre::Degree const *)arg1)->operator <((Ogre::Degree const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.<=

  call-seq:
    <=(d) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_Degree___le__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator <=", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator <=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator <=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = (bool)((Ogre::Degree const *)arg1)->operator <=((Ogre::Degree const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.==

  call-seq:
    ==(d) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Degree___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = (bool)((Ogre::Degree const *)arg1)->operator ==((Ogre::Degree const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.>=

  call-seq:
    >=(d) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_Degree___ge__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator >=", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator >=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator >=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = (bool)((Ogre::Degree const *)arg1)->operator >=((Ogre::Degree const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Degree.>

  call-seq:
    >(d) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Degree___gt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = (Ogre::Degree *) 0 ;
  Ogre::Degree *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_Ogre__Degree, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const *","operator >", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","operator >", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","operator >", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = (bool)((Ogre::Degree const *)arg1)->operator >((Ogre::Degree const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Degree(Ogre::Degree *arg1) {
    delete arg1;
}

swig_class SwigClassAngle;

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

SWIGINTERN VALUE
_wrap_new_Angle(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Angle";
  Ogre::Angle *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","Ogre::Angle", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Angle *)new Ogre::Angle(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Angle(Ogre::Angle *arg1) {
    delete arg1;
}

swig_class SwigClassMath;

SWIGINTERN VALUE
_wrap_new_Math__SWIG_0(int argc, VALUE *argv, VALUE self) {
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Math";
  Ogre::Math *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Ogre::Math", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (Ogre::Math *)new Ogre::Math(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Math__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Math";
  Ogre::Math *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Math *)new Ogre::Math();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Math(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_Math__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Math__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Math.new", 
    "    Math.new(unsigned int trigTableSize)\n"
    "    Math.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Math(Ogre::Math *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Math_IAbs(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  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( "", "int","Ogre::Math::IAbs", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (int)Ogre::Math::IAbs(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_ICeil(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  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( "", "float","Ogre::Math::ICeil", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  result = (int)Ogre::Math::ICeil(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_IFloor(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  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( "", "float","Ogre::Math::IFloor", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  result = (int)Ogre::Math::IFloor(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_ISign(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  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( "", "int","Ogre::Math::ISign", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = (int)Ogre::Math::ISign(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Abs__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Abs", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Abs(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Abs__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Degree 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__Degree,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const &","Ogre::Math::Abs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","Ogre::Math::Abs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = Ogre::Math::Abs((Ogre::Degree const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Abs__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Radian 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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Abs", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Abs", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = Ogre::Math::Abs((Ogre::Radian const &)*arg1);
  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_Math_Abs(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Abs__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Abs__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_Math_Abs__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Math.Abs", 
    "    Ogre::Radian Math.Abs(Ogre::Real fValue)\n"
    "    Ogre::Radian Math.Abs(Ogre::Degree const &dValue)\n"
    "    Ogre::Radian Math.Abs(Ogre::Radian const &rValue)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_ACos(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  Ogre::Radian result;
  VALUE vresult = Qnil;
  
  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","Ogre::Math::ACos", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = Ogre::Math::ACos(arg1);
  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_Math_ASin(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  Ogre::Radian result;
  VALUE vresult = Qnil;
  
  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","Ogre::Math::ASin", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = Ogre::Math::ASin(arg1);
  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_Math_ATan(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  Ogre::Radian result;
  VALUE vresult = Qnil;
  
  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","Ogre::Math::ATan", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = Ogre::Math::ATan(arg1);
  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_Math_ATan2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::ATan2", 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","Ogre::Math::ATan2", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = Ogre::Math::ATan2(arg1,arg2);
  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_Math_Ceil(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Ceil", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Ceil(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_isNaN(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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","Ogre::Math::isNaN", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (bool)Ogre::Math::isNaN(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Cos__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Cos", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Cos", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Math::Cos", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Real)Ogre::Math::Cos((Ogre::Radian const &)*arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Cos__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  void *argp1 ;
  int res1 = 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Cos", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Cos", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Real)Ogre::Math::Cos((Ogre::Radian const &)*arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Cos__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  bool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Cos", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Math::Cos", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Real)Ogre::Math::Cos(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Cos__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Cos", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Cos(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_Cos(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__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Cos__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Math_Cos__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Math_Cos__SWIG_0(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_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Math_Cos__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Math.Cos", 
    "    Ogre::Real Math.Cos(Ogre::Radian const &fValue, bool useTables)\n"
    "    Ogre::Real Math.Cos(Ogre::Radian const &fValue)\n"
    "    Ogre::Real Math.Cos(Ogre::Real fValue, bool useTables)\n"
    "    Ogre::Real Math.Cos(Ogre::Real fValue)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Exp(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Exp", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Exp(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Floor(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Floor", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Floor(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Log(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Log", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Log(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_LOG2_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::LOG2));
  return _val;
}


SWIGINTERN VALUE
_wrap_Math_Log2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Log2", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Log2(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_LogN(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::LogN", 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","Ogre::Math::LogN", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)Ogre::Math::LogN(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Pow(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Pow", 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","Ogre::Math::Pow", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)Ogre::Math::Pow(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sign__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Sign", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Sign(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sign__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Radian 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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Sign", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Sign", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = Ogre::Math::Sign((Ogre::Radian const &)*arg1);
  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_Math_Sign__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Degree 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__Degree,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const &","Ogre::Math::Sign", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","Ogre::Math::Sign", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = Ogre::Math::Sign((Ogre::Degree const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_Sign(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Sign__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Sign__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_Math_Sign__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Math.Sign", 
    "    Ogre::Degree Math.Sign(Ogre::Real fValue)\n"
    "    Ogre::Degree Math.Sign(Ogre::Radian const &rValue)\n"
    "    Ogre::Degree Math.Sign(Ogre::Degree const &dValue)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Sin", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Sin", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Math::Sin", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Real)Ogre::Math::Sin((Ogre::Radian const &)*arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  void *argp1 ;
  int res1 = 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Sin", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Sin", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Real)Ogre::Math::Sin((Ogre::Radian const &)*arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sin__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  bool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Sin", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Math::Sin", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Real)Ogre::Math::Sin(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sin__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Sin", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Sin(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_Sin(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__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Sin__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Math_Sin__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Math_Sin__SWIG_0(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_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Math_Sin__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Math.Sin", 
    "    Ogre::Real Math.Sin(Ogre::Radian const &fValue, bool useTables)\n"
    "    Ogre::Real Math.Sin(Ogre::Radian const &fValue)\n"
    "    Ogre::Real Math.Sin(Ogre::Real fValue, bool useTables)\n"
    "    Ogre::Real Math.Sin(Ogre::Real fValue)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sqr(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Sqr", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Sqr(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sqrt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Sqrt", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Sqrt(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Sqrt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Radian 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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Sqrt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Sqrt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = Ogre::Math::Sqrt((Ogre::Radian const &)*arg1);
  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_Math_Sqrt__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Degree 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__Degree,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree const &","Ogre::Math::Sqrt", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","Ogre::Math::Sqrt", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Degree * >(argp1);
  result = Ogre::Math::Sqrt((Ogre::Degree const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_Sqrt(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Sqrt__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Sqrt__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_Math_Sqrt__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Math.Sqrt", 
    "    Ogre::Degree Math.Sqrt(Ogre::Real fValue)\n"
    "    Ogre::Degree Math.Sqrt(Ogre::Radian const &fValue)\n"
    "    Ogre::Degree Math.Sqrt(Ogre::Degree const &fValue)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_InvSqrt(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::InvSqrt", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::InvSqrt(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_UnitRandom(int argc, VALUE *argv, VALUE self) {
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Real)Ogre::Math::UnitRandom();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_RangeRandom(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::RangeRandom", 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","Ogre::Math::RangeRandom", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)Ogre::Math::RangeRandom(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_SymmetricRandom(int argc, VALUE *argv, VALUE self) {
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Real)Ogre::Math::SymmetricRandom();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Tan__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  bool arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Tan", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Tan", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Math::Tan", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Real)Ogre::Math::Tan((Ogre::Radian const &)*arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Tan__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  void *argp1 ;
  int res1 = 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Math::Tan", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Math::Tan", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(argp1);
  result = (Ogre::Real)Ogre::Math::Tan((Ogre::Radian const &)*arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Tan__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  bool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Tan", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Math::Tan", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Real)Ogre::Math::Tan(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_Tan__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::Tan", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::Tan(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_Tan(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__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Math_Tan__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Math_Tan__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Math_Tan__SWIG_0(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_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Math_Tan__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Math.Tan", 
    "    Ogre::Real Math.Tan(Ogre::Radian const &fValue, bool useTables)\n"
    "    Ogre::Real Math.Tan(Ogre::Radian const &fValue)\n"
    "    Ogre::Real Math.Tan(Ogre::Real fValue, bool useTables)\n"
    "    Ogre::Real Math.Tan(Ogre::Real fValue)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_DegreesToRadians(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::DegreesToRadians", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::DegreesToRadians(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_RadiansToDegrees(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::RadiansToDegrees", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::RadiansToDegrees(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_setAngleUnit(int argc, VALUE *argv, VALUE self) {
  Ogre::Math::AngleUnit arg1 ;
  int val1 ;
  int ecode1 = 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( "", "Ogre::Math::AngleUnit","Ogre::Math::setAngleUnit", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Math::AngleUnit >(val1);
  Ogre::Math::setAngleUnit(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_getAngleUnit(int argc, VALUE *argv, VALUE self) {
  Ogre::Math::AngleUnit result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Math::AngleUnit)Ogre::Math::getAngleUnit();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_AngleUnitsToRadians(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::AngleUnitsToRadians", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::AngleUnitsToRadians(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_RadiansToAngleUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::RadiansToAngleUnits", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::RadiansToAngleUnits(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_AngleUnitsToDegrees(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::AngleUnitsToDegrees", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::AngleUnitsToDegrees(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_DegreesToAngleUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::DegreesToAngleUnits", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::DegreesToAngleUnits(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_pointInTri2D(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Ogre::Vector2 *arg3 = 0 ;
  Ogre::Vector2 *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::Math::pointInTri2D", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Ogre::Math::pointInTri2D", 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 &","Ogre::Math::pointInTri2D", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Ogre::Math::pointInTri2D", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Ogre::Math::pointInTri2D", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Ogre::Math::pointInTri2D", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector2 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","Ogre::Math::pointInTri2D", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Ogre::Math::pointInTri2D", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector2 * >(argp4);
  result = (bool)Ogre::Math::pointInTri2D((Ogre::Vector2 const &)*arg1,(Ogre::Vector2 const &)*arg2,(Ogre::Vector2 const &)*arg3,(Ogre::Vector2 const &)*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_pointInTri3D(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",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 &","Ogre::Math::pointInTri3D", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 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 &","Ogre::Math::pointInTri3D", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::pointInTri3D", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  result = (bool)Ogre::Math::pointInTri3D((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Plane *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Plane const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Sphere *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Sphere const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Sphere *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Sphere const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::Real *arg3 = (Ogre::Real *) 0 ;
  Ogre::Real *arg4 = (Ogre::Real *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real *","Ogre::Math::intersects", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real *","Ogre::Math::intersects", 4, argv[3] )); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  result = (bool)Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 7, argv[6] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5,arg6);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  bool arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,arg5);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::intersects", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__Sphere,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)Ogre::Math::intersects((Ogre::Sphere const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__Plane,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)Ogre::Math::intersects((Ogre::Plane const &)*arg1,(Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_13(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_14(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = 0 ;
  Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type *arg2 = 0 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::Math::intersects", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = Ogre::Math::intersects((Ogre::Ray const &)*arg1,(Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_intersects__SWIG_15(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = 0 ;
  Ogre::Plane *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__Sphere,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const &","Ogre::Math::intersects", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","Ogre::Math::intersects", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","Ogre::Math::intersects", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","Ogre::Math::intersects", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  result = (bool)Ogre::Math::intersects((Ogre::Sphere const &)*arg1,(Ogre::Plane const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_intersects(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs;
  if (argc > 7) 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__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Math_intersects__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Math_intersects__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Math_intersects__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Math_intersects__SWIG_11(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Math_intersects__SWIG_12(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Math_intersects__SWIG_15(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Math_intersects__SWIG_13(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Math_intersects__SWIG_14(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Math_intersects__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 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_Math_intersects__SWIG_10(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Math_intersects__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Math_intersects__SWIG_7(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 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) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Math_intersects__SWIG_9(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Math_intersects__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 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) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Math_intersects__SWIG_8(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Math_intersects__SWIG_5(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Math.intersects", 
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Plane const &plane)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Sphere const &sphere, bool discardInside)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Sphere const &sphere)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::AxisAlignedBox const &box)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::AxisAlignedBox const &box, Ogre::Real *d1, Ogre::Real *d2)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Vector3 const &a, Ogre::Vector3 const &b, Ogre::Vector3 const &c, Ogre::Vector3 const &normal, bool positiveSide, bool negativeSide)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Vector3 const &a, Ogre::Vector3 const &b, Ogre::Vector3 const &c, Ogre::Vector3 const &normal, bool positiveSide)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Vector3 const &a, Ogre::Vector3 const &b, Ogre::Vector3 const &c, Ogre::Vector3 const &normal)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Vector3 const &a, Ogre::Vector3 const &b, Ogre::Vector3 const &c, bool positiveSide, bool negativeSide)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Vector3 const &a, Ogre::Vector3 const &b, Ogre::Vector3 const &c, bool positiveSide)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::Vector3 const &a, Ogre::Vector3 const &b, Ogre::Vector3 const &c)\n"
    "    bool Math.intersects(Ogre::Sphere const &sphere, Ogre::AxisAlignedBox const &box)\n"
    "    bool Math.intersects(Ogre::Plane const &plane, Ogre::AxisAlignedBox const &box)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &planeList, bool normalIsOutside)\n"
    "    bool Math.intersects(Ogre::Ray const &ray, Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type const &planeList, bool normalIsOutside)\n"
    "    bool Math.intersects(Ogre::Sphere const &sphere, Ogre::Plane const &plane)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_RealEqual__SWIG_0(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 ;
  bool 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::RealEqual", 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","Ogre::Math::RealEqual", 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","Ogre::Math::RealEqual", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)Ogre::Math::RealEqual(arg1,arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_RealEqual__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  bool 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::RealEqual", 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","Ogre::Math::RealEqual", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (bool)Ogre::Math::RealEqual(arg1,arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_RealEqual(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 == 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_Math_RealEqual__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_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_Math_RealEqual__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Math.RealEqual", 
    "    bool Math.RealEqual(Ogre::Real a, Ogre::Real b, Ogre::Real tolerance)\n"
    "    bool Math.RealEqual(Ogre::Real a, Ogre::Real b)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_calculateTangentSpaceVector(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Real arg8 ;
  Ogre::Real arg9 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  Ogre::Vector3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",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 &","Ogre::Math::calculateTangentSpaceVector", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateTangentSpaceVector", 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 &","Ogre::Math::calculateTangentSpaceVector", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateTangentSpaceVector", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateTangentSpaceVector", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateTangentSpaceVector", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::calculateTangentSpaceVector", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::calculateTangentSpaceVector", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::calculateTangentSpaceVector", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::calculateTangentSpaceVector", 7, argv[6] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_float(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::calculateTangentSpaceVector", 8, argv[7] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_float(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::calculateTangentSpaceVector", 9, argv[8] ));
  } 
  arg9 = static_cast< Ogre::Real >(val9);
  result = Ogre::Math::calculateTangentSpaceVector((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  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_Math_buildReflectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Matrix4 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__Plane,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const &","Ogre::Math::buildReflectionMatrix", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","Ogre::Math::buildReflectionMatrix", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  result = Ogre::Math::buildReflectionMatrix((Ogre::Plane const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_calculateFaceNormal(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Vector4 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormal", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormal", 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 &","Ogre::Math::calculateFaceNormal", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormal", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormal", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormal", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = Ogre::Math::calculateFaceNormal((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_calculateBasicFaceNormal(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Vector3 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormal", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormal", 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 &","Ogre::Math::calculateBasicFaceNormal", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormal", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormal", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormal", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = Ogre::Math::calculateBasicFaceNormal((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  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_Math_calculateFaceNormalWithoutNormalize(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Vector4 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormalWithoutNormalize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormalWithoutNormalize", 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 &","Ogre::Math::calculateFaceNormalWithoutNormalize", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormalWithoutNormalize", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormalWithoutNormalize", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateFaceNormalWithoutNormalize", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = Ogre::Math::calculateFaceNormalWithoutNormalize((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_calculateBasicFaceNormalWithoutNormalize(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Vector3 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormalWithoutNormalize", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormalWithoutNormalize", 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 &","Ogre::Math::calculateBasicFaceNormalWithoutNormalize", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormalWithoutNormalize", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormalWithoutNormalize", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::calculateBasicFaceNormalWithoutNormalize", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = Ogre::Math::calculateBasicFaceNormalWithoutNormalize((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  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_Math_gaussianDistribution__SWIG_0(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 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::gaussianDistribution", 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","Ogre::Math::gaussianDistribution", 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","Ogre::Math::gaussianDistribution", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Real)Ogre::Math::gaussianDistribution(arg1,arg2,arg3);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_gaussianDistribution__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Real 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::gaussianDistribution", 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","Ogre::Math::gaussianDistribution", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)Ogre::Math::gaussianDistribution(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_gaussianDistribution__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Math::gaussianDistribution", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Real)Ogre::Math::gaussianDistribution(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_gaussianDistribution(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Math_gaussianDistribution__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_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Math_gaussianDistribution__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_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_Math_gaussianDistribution__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Math.gaussianDistribution", 
    "    Ogre::Real Math.gaussianDistribution(Ogre::Real x, Ogre::Real offset, Ogre::Real scale)\n"
    "    Ogre::Real Math.gaussianDistribution(Ogre::Real x, Ogre::Real offset)\n"
    "    Ogre::Real Math.gaussianDistribution(Ogre::Real x)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_makeViewMatrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = (Ogre::Matrix4 *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Matrix4 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Math::makeViewMatrix", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::makeViewMatrix", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Math::makeViewMatrix", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Math::makeViewMatrix", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","Ogre::Math::makeViewMatrix", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  result = Ogre::Math::makeViewMatrix((Ogre::Vector3 const &)*arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Matrix4 const *)arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_makeViewMatrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix4 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 &","Ogre::Math::makeViewMatrix", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Math::makeViewMatrix", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Math::makeViewMatrix", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Math::makeViewMatrix", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = Ogre::Math::makeViewMatrix((Ogre::Vector3 const &)*arg1,(Ogre::Quaternion const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Math_makeViewMatrix(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 == 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__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Math_makeViewMatrix__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Math_makeViewMatrix__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Math.makeViewMatrix", 
    "    Ogre::Matrix4 Math.makeViewMatrix(Ogre::Vector3 const &position, Ogre::Quaternion const &orientation, Ogre::Matrix4 const *reflectMatrix)\n"
    "    Ogre::Matrix4 Math.makeViewMatrix(Ogre::Vector3 const &position, Ogre::Quaternion const &orientation)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_boundingRadiusFromAABB(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = 0 ;
  void *argp1 ;
  int res1 = 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(argv[0], &argp1, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","Ogre::Math::boundingRadiusFromAABB", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","Ogre::Math::boundingRadiusFromAABB", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::Real)Ogre::Math::boundingRadiusFromAABB((Ogre::AxisAlignedBox const &)*arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Math_POS_INFINITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::POS_INFINITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Math_NEG_INFINITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::NEG_INFINITY));
  return _val;
}


SWIGINTERN VALUE
_wrap_Math_PI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::PI));
  return _val;
}


SWIGINTERN VALUE
_wrap_Math_TWO_PI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::TWO_PI));
  return _val;
}


SWIGINTERN VALUE
_wrap_Math_HALF_PI_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::HALF_PI));
  return _val;
}


SWIGINTERN VALUE
_wrap_Math_fDeg2Rad_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::fDeg2Rad));
  return _val;
}


SWIGINTERN VALUE
_wrap_Math_fRad2Deg_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Math::fRad2Deg));
  return _val;
}


SWIGINTERN VALUE
_wrap___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Radian *arg2 = 0 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::operator *", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  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 const &","Ogre::operator *", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::operator *", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = Ogre::operator *(arg1,(Ogre::Radian const &)*arg2);
  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___div____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Radian *arg2 = 0 ;
  float val1 ;
  int ecode1 = 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;
  }
  ecode1 = SWIG_AsVal_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::operator /", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  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 const &","Ogre::operator /", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::operator /", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = Ogre::operator /(arg1,(Ogre::Radian const &)*arg2);
  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___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Degree *arg2 = 0 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Degree 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::operator *", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","Ogre::operator *", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","Ogre::operator *", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = Ogre::operator *(arg1,(Ogre::Degree const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___div____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Degree *arg2 = 0 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Degree 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::operator /", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","Ogre::operator /", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","Ogre::operator /", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  result = Ogre::operator /(arg1,(Ogre::Degree const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___div__(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;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___div____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___div____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__div__", 
    "    Ogre::Degree __div__(Ogre::Real a, Ogre::Radian const &b)\n"
    "    Ogre::Degree __div__(Ogre::Real a, Ogre::Degree const &b)\n");
  
  return Qnil;
}


swig_class SwigClassVector2;

SWIGINTERN VALUE
_wrap_Vector2_x_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","x", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->x = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_x_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Real) ((arg1)->x);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_y_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","y", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->y = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_y_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Real) ((arg1)->y);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Vector2";
  Ogre::Vector2 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Vector2 *)new Ogre::Vector2();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector2__SWIG_1(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 = "Ogre::Vector2";
  Ogre::Vector2 *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","Ogre::Vector2", 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","Ogre::Vector2", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Vector2 *)new Ogre::Vector2(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector2__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector2";
  Ogre::Vector2 *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","Ogre::Vector2", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Vector2 *)new Ogre::Vector2(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector2__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector2";
  Ogre::Vector2 *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real const [2]","Ogre::Vector2", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::Vector2 *)new Ogre::Vector2((Ogre::Real const (*))arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector2__SWIG_4(int argc, VALUE *argv, VALUE self) {
  int *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector2";
  Ogre::Vector2 *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_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int const [2]","Ogre::Vector2", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< int * >(argp1);
  result = (Ogre::Vector2 *)new Ogre::Vector2((int const (*))arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Vector2__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 = (Ogre::Real *) (Ogre::Real *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector2";
  Ogre::Vector2 *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real *const","Ogre::Vector2", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::Vector2 *)new Ogre::Vector2(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Vector2(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_Vector2__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector2__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector2__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector2__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_Vector2__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_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Vector2__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Vector2.new", 
    "    Vector2.new()\n"
    "    Vector2.new(Ogre::Real const fX, Ogre::Real const fY)\n"
    "    Vector2.new(Ogre::Real const scaler)\n"
    "    Vector2.new(Ogre::Real const afCoordinate[2])\n"
    "    Vector2.new(int const afCoordinate[2])\n"
    "    Vector2.new(Ogre::Real *const r)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_ptr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Real *)(arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_ptr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Real *)((Ogre::Vector2 const *)arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector2_ptr(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_Ogre__Vector2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector2_ptr__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector2_ptr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Vector2.ptr", 
    "    Ogre::Real const * Vector2.ptr()\n"
    "    Ogre::Real const * Vector2.ptr()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Vector2.==

  call-seq:
    ==(rkVector) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Vector2___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = (bool)((Ogre::Vector2 const *)arg1)->operator ==((Ogre::Vector2 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector2.+

  call-seq:
    +(rkVector) -> Vector2

Add operator.
*/
SWIGINTERN VALUE
_wrap_Vector2___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = ((Ogre::Vector2 const *)arg1)->operator +((Ogre::Vector2 const &)*arg2);
  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;
}



/*
  Document-method: Ogre::Vector2.-

  call-seq:
    -(rkVector) -> Vector2

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Vector2___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = ((Ogre::Vector2 const *)arg1)->operator -((Ogre::Vector2 const &)*arg2);
  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_Vector2___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Vector2 const *)arg1)->operator *(arg2);
  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_Vector2___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = ((Ogre::Vector2 const *)arg1)->operator *((Ogre::Vector2 const &)*arg2);
  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_Vector2___mul__(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_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_Vector2___mul____SWIG_1(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) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector2___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Vector2.__mul__", 
    "    Ogre::Vector2 Vector2.__mul__(Ogre::Real const fScalar)\n"
    "    Ogre::Vector2 Vector2.__mul__(Ogre::Vector2 const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2___div____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Vector2 const *)arg1)->operator /(arg2);
  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_Vector2___div____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","operator /", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","operator /", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = ((Ogre::Vector2 const *)arg1)->operator /((Ogre::Vector2 const &)*arg2);
  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_Vector2___div__(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_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_Vector2___div____SWIG_1(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) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector2___div____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Vector2.__div__", 
    "    Ogre::Vector2 Vector2.__div__(Ogre::Real const fScalar)\n"
    "    Ogre::Vector2 Vector2.__div__(Ogre::Vector2 const &rhs)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Vector2.+@

  call-seq:
    +@ -> Vector2

Add operator.
*/
SWIGINTERN VALUE
_wrap_Vector2___pos__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Vector2 *) &((Ogre::Vector2 const *)arg1)->operator +();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector2.-@

  call-seq:
    -@ -> Vector2

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Vector2___neg__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = ((Ogre::Vector2 const *)arg1)->operator -();
  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;
}



/*
  Document-method: Ogre::Vector2.length

  call-seq:
    length -> Real

Size or Length of the Vector2.
*/
SWIGINTERN VALUE
_wrap_Vector2_length(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","length", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->length();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_squaredLength(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","squaredLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->squaredLength();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_distance(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","distance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","distance", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","distance", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->distance((Ogre::Vector2 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_squaredDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","squaredDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","squaredDistance", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","squaredDistance", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->squaredDistance((Ogre::Vector2 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_dotProduct(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","dotProduct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","dotProduct", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","dotProduct", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->dotProduct((Ogre::Vector2 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_normalise(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","normalise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (Ogre::Real)(arg1)->normalise();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_midPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","midPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","midPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","midPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = ((Ogre::Vector2 const *)arg1)->midPoint((Ogre::Vector2 const &)*arg2);
  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;
}



/*
  Document-method: Ogre::Vector2.<

  call-seq:
    <(rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Vector2___lt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = (bool)((Ogre::Vector2 const *)arg1)->operator <((Ogre::Vector2 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector2.>

  call-seq:
    >(rhs) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Vector2___gt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","operator >", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","operator >", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","operator >", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = (bool)((Ogre::Vector2 const *)arg1)->operator >((Ogre::Vector2 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_makeFloor(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","makeFloor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","makeFloor", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","makeFloor", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->makeFloor((Ogre::Vector2 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_makeCeil(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 *","makeCeil", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","makeCeil", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","makeCeil", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->makeCeil((Ogre::Vector2 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_perpendicular(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","perpendicular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = ((Ogre::Vector2 const *)arg1)->perpendicular();
  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_Vector2_crossProduct(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","crossProduct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","crossProduct", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","crossProduct", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector2 const *)arg1)->crossProduct((Ogre::Vector2 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_randomDeviant(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","randomDeviant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","randomDeviant", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Vector2 const *)arg1)->randomDeviant(arg2);
  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_Vector2_isZeroLength(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","isZeroLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (bool)((Ogre::Vector2 const *)arg1)->isZeroLength();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_normalisedCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","normalisedCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = ((Ogre::Vector2 const *)arg1)->normalisedCopy();
  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_Vector2_reflect(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","reflect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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);
  result = ((Ogre::Vector2 const *)arg1)->reflect((Ogre::Vector2 const &)*arg2);
  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_Vector2_isNaN(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","isNaN", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = (bool)((Ogre::Vector2 const *)arg1)->isNaN();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector2_angleBetween(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","angleBetween", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","angleBetween", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","angleBetween", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = ((Ogre::Vector2 const *)arg1)->angleBetween((Ogre::Vector2 const &)*arg2);
  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_Vector2_angleTo(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = (Ogre::Vector2 *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","angleTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(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 &","angleTo", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","angleTo", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = ((Ogre::Vector2 const *)arg1)->angleTo((Ogre::Vector2 const &)*arg2);
  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_Vector2_ZERO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector2::ZERO), SWIGTYPE_p_Ogre__Vector2,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector2_UNIT_X_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector2::UNIT_X), SWIGTYPE_p_Ogre__Vector2,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector2_UNIT_Y_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector2::UNIT_Y), SWIGTYPE_p_Ogre__Vector2,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector2_NEGATIVE_UNIT_X_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector2::NEGATIVE_UNIT_X), SWIGTYPE_p_Ogre__Vector2,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector2_NEGATIVE_UNIT_Y_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector2::NEGATIVE_UNIT_Y), SWIGTYPE_p_Ogre__Vector2,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector2_UNIT_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector2::UNIT_SCALE), SWIGTYPE_p_Ogre__Vector2,  0 );
  return _val;
}


SWIGINTERN void
free_Ogre_Vector2(Ogre::Vector2 *arg1) {
    delete arg1;
}

swig_class SwigClassQuaternion;

SWIGINTERN VALUE
_wrap_new_Quaternion__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Quaternion";
  Ogre::Quaternion *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Quaternion *)new Ogre::Quaternion();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Quaternion__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Quaternion";
  Ogre::Quaternion *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","Ogre::Quaternion", 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","Ogre::Quaternion", 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","Ogre::Quaternion", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Quaternion", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::Quaternion *)new Ogre::Quaternion(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Quaternion__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Quaternion";
  Ogre::Quaternion *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__Matrix3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","Ogre::Quaternion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","Ogre::Quaternion", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Matrix3 const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Quaternion__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Quaternion";
  Ogre::Quaternion *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__Radian,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian const &","Ogre::Quaternion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","Ogre::Quaternion", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Radian * >(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 &","Ogre::Quaternion", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Quaternion", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Radian const &)*arg1,(Ogre::Vector3 const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Quaternion__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Quaternion";
  Ogre::Quaternion *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Quaternion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Quaternion", 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 &","Ogre::Quaternion", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Quaternion", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Quaternion", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Quaternion", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Quaternion__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Quaternion";
  Ogre::Quaternion *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__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","Ogre::Quaternion", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Quaternion *)new Ogre::Quaternion((Ogre::Vector3 const *)arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Quaternion__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Quaternion";
  Ogre::Quaternion *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real *","Ogre::Quaternion", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::Quaternion *)new Ogre::Quaternion(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Quaternion(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_Quaternion__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Quaternion__SWIG_2(nargs, args, self);
    }
  }
  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_new_Quaternion__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Quaternion__SWIG_6(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 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_Quaternion__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Quaternion__SWIG_4(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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Quaternion__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Quaternion.new", 
    "    Quaternion.new()\n"
    "    Quaternion.new(Ogre::Real fW, Ogre::Real fX, Ogre::Real fY, Ogre::Real fZ)\n"
    "    Quaternion.new(Ogre::Matrix3 const &rot)\n"
    "    Quaternion.new(Ogre::Radian const &rfAngle, Ogre::Vector3 const &rkAxis)\n"
    "    Quaternion.new(Ogre::Vector3 const &xaxis, Ogre::Vector3 const &yaxis, Ogre::Vector3 const &zaxis)\n"
    "    Quaternion.new(Ogre::Vector3 const *akAxis)\n"
    "    Quaternion.new(Ogre::Real *valptr)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Quaternion *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_ptr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real *)(arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_ptr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real *)((Ogre::Quaternion const *)arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_ptr(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_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Quaternion_ptr__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Quaternion_ptr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Quaternion.ptr", 
    "    Ogre::Real const * Quaternion.ptr()\n"
    "    Ogre::Real const * Quaternion.ptr()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_FromRotationMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Matrix3 *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","FromRotationMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","FromRotationMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","FromRotationMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  (arg1)->FromRotationMatrix((Ogre::Matrix3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_ToRotationMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Matrix3 *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","ToRotationMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","ToRotationMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","ToRotationMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  ((Ogre::Quaternion const *)arg1)->ToRotationMatrix(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_FromAngleAxis(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Radian *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","FromAngleAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 const &","FromAngleAxis", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromAngleAxis", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(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 &","FromAngleAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAngleAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->FromAngleAxis((Ogre::Radian const &)*arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_ToAngleAxis__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Vector3 *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","ToAngleAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","ToAngleAxis", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToAngleAxis", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(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 &","ToAngleAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","ToAngleAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ((Ogre::Quaternion const *)arg1)->ToAngleAxis(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_ToAngleAxis__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Degree *arg2 = 0 ;
  Ogre::Vector3 *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","ToAngleAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree &","ToAngleAxis", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree &","ToAngleAxis", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(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 &","ToAngleAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","ToAngleAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ((Ogre::Quaternion const *)arg1)->ToAngleAxis(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_ToAngleAxis(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 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_Quaternion_ToAngleAxis__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 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_Quaternion_ToAngleAxis__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Quaternion.ToAngleAxis", 
    "    void Quaternion.ToAngleAxis(Ogre::Radian &rfAngle, Ogre::Vector3 &rkAxis)\n"
    "    void Quaternion.ToAngleAxis(Ogre::Degree &dAngle, Ogre::Vector3 &rkAxis)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_FromAxes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","FromAxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","FromAxes", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->FromAxes((Ogre::Vector3 const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_FromAxes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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 ;
  
  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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","FromAxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","FromAxes", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAxes", 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 &","FromAxes", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAxes", 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 &","FromAxes", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAxes", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->FromAxes((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_FromAxes(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_Ogre__Quaternion, 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_Quaternion_FromAxes__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 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_Quaternion_FromAxes__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Quaternion.FromAxes", 
    "    void Quaternion.FromAxes(Ogre::Vector3 const *akAxis)\n"
    "    void Quaternion.FromAxes(Ogre::Vector3 const &xAxis, Ogre::Vector3 const &yAxis, Ogre::Vector3 const &zAxis)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_ToAxes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","ToAxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","ToAxes", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ((Ogre::Quaternion const *)arg1)->ToAxes(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_ToAxes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","ToAxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","ToAxes", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","ToAxes", 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 &","ToAxes", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","ToAxes", 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 &","ToAxes", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","ToAxes", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  ((Ogre::Quaternion const *)arg1)->ToAxes(*arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Quaternion_ToAxes(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_Ogre__Quaternion, 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_Quaternion_ToAxes__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 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_Quaternion_ToAxes__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Quaternion.ToAxes", 
    "    void Quaternion.ToAxes(Ogre::Vector3 *akAxis)\n"
    "    void Quaternion.ToAxes(Ogre::Vector3 &xAxis, Ogre::Vector3 &yAxis, Ogre::Vector3 &zAxis)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_xAxis(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","xAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->xAxis();
  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_Quaternion_yAxis(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","yAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->yAxis();
  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_Quaternion_zAxis(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","zAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->zAxis();
  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;
}



/*
  Document-method: Ogre::Quaternion.+

  call-seq:
    +(rkQ) -> Quaternion

Add operator.
*/
SWIGINTERN VALUE
_wrap_Quaternion___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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(self, &argp1,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = ((Ogre::Quaternion const *)arg1)->operator +((Ogre::Quaternion const &)*arg2);
  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;
}



/*
  Document-method: Ogre::Quaternion.-

  call-seq:
    -(rkQ) -> Quaternion

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Quaternion___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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(self, &argp1,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = ((Ogre::Quaternion const *)arg1)->operator -((Ogre::Quaternion const &)*arg2);
  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_Quaternion___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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(self, &argp1,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = ((Ogre::Quaternion const *)arg1)->operator *((Ogre::Quaternion const &)*arg2);
  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_Quaternion___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 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(self, &argp1,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Quaternion const *)arg1)->operator *(arg2);
  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;
}



/*
  Document-method: Ogre::Quaternion.-@

  call-seq:
    -@ -> Quaternion

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Quaternion___neg__(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->operator -();
  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;
}



/*
  Document-method: Ogre::Quaternion.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Quaternion___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Quaternion *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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = (bool)((Ogre::Quaternion const *)arg1)->operator ==((Ogre::Quaternion const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_Dot(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","Dot", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","Dot", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Dot", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = (Ogre::Real)((Ogre::Quaternion const *)arg1)->Dot((Ogre::Quaternion const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_Norm(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","Norm", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real)((Ogre::Quaternion const *)arg1)->Norm();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_normalise(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","normalise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real)(arg1)->normalise();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_Inverse(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","Inverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->Inverse();
  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_Quaternion_UnitInverse(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","UnitInverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->UnitInverse();
  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_Quaternion_Exp(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","Exp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->Exp();
  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_Quaternion_Log(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","Log", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->Log();
  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_Quaternion___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Quaternion const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
  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_Quaternion___mul__(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_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Quaternion___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 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_Quaternion___mul____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Quaternion___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Quaternion.__mul__", 
    "    Ogre::Vector3 Quaternion.__mul__(Ogre::Quaternion const &rkQ)\n"
    "    Ogre::Vector3 Quaternion.__mul__(Ogre::Real fScalar)\n"
    "    Ogre::Vector3 Quaternion.__mul__(Ogre::Vector3 const &rkVector)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_getRoll__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Radian 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","getRoll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getRoll", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = ((Ogre::Quaternion const *)arg1)->getRoll(arg2);
  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_Quaternion_getRoll__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","getRoll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->getRoll();
  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_Quaternion_getRoll(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_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Quaternion_getRoll__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Quaternion_getRoll__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Quaternion.getRoll", 
    "    Ogre::Radian Quaternion.getRoll(bool reprojectAxis)\n"
    "    Ogre::Radian Quaternion.getRoll()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_getPitch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Radian 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","getPitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getPitch", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = ((Ogre::Quaternion const *)arg1)->getPitch(arg2);
  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_Quaternion_getPitch__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","getPitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->getPitch();
  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_Quaternion_getPitch(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_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Quaternion_getPitch__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Quaternion_getPitch__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Quaternion.getPitch", 
    "    Ogre::Radian Quaternion.getPitch(bool reprojectAxis)\n"
    "    Ogre::Radian Quaternion.getPitch()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_getYaw__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Radian 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","getYaw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getYaw", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = ((Ogre::Quaternion const *)arg1)->getYaw(arg2);
  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_Quaternion_getYaw__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","getYaw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = ((Ogre::Quaternion const *)arg1)->getYaw();
  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_Quaternion_getYaw(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_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Quaternion_getYaw__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Quaternion_getYaw__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Quaternion.getYaw", 
    "    Ogre::Radian Quaternion.getYaw(bool reprojectAxis)\n"
    "    Ogre::Radian Quaternion.getYaw()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_equals(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","equals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","equals", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","equals", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","equals", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","equals", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  result = (bool)((Ogre::Quaternion const *)arg1)->equals((Ogre::Quaternion const &)*arg2,(Ogre::Radian const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_Slerp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  bool arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::Quaternion result;
  VALUE vresult = Qnil;
  
  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","Ogre::Quaternion::Slerp", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::Quaternion::Slerp", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = Ogre::Quaternion::Slerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,arg4);
  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_Quaternion_Slerp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Quaternion 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Quaternion::Slerp", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Slerp", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  result = Ogre::Quaternion::Slerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3);
  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_Quaternion_Slerp(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 == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Quaternion_Slerp__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Quaternion_Slerp__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Quaternion.Slerp", 
    "    Ogre::Quaternion Quaternion.Slerp(Ogre::Real fT, Ogre::Quaternion const &rkP, Ogre::Quaternion const &rkQ, bool shortestPath)\n"
    "    Ogre::Quaternion Quaternion.Slerp(Ogre::Real fT, Ogre::Quaternion const &rkP, Ogre::Quaternion const &rkQ)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_SlerpExtraSpins(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  int arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::Quaternion result;
  VALUE vresult = Qnil;
  
  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","Ogre::Quaternion::SlerpExtraSpins", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::SlerpExtraSpins", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::SlerpExtraSpins", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::SlerpExtraSpins", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::SlerpExtraSpins", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Ogre::Quaternion::SlerpExtraSpins", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  result = Ogre::Quaternion::SlerpExtraSpins(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,arg4);
  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_Quaternion_Intermediate(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  Ogre::Quaternion *arg5 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Intermediate", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Intermediate", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Intermediate", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Intermediate", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Intermediate", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Intermediate", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion &","Ogre::Quaternion::Intermediate", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion &","Ogre::Quaternion::Intermediate", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Quaternion &","Ogre::Quaternion::Intermediate", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion &","Ogre::Quaternion::Intermediate", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< Ogre::Quaternion * >(argp5);
  Ogre::Quaternion::Intermediate((Ogre::Quaternion const &)*arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,*arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_Squad__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  Ogre::Quaternion *arg5 = 0 ;
  bool arg6 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::Quaternion result;
  VALUE vresult = Qnil;
  
  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","Ogre::Quaternion::Squad", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< Ogre::Quaternion * >(argp5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::Quaternion::Squad", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = Ogre::Quaternion::Squad(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Quaternion const &)*arg5,arg6);
  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_Quaternion_Squad__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  Ogre::Quaternion *arg5 = 0 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Ogre::Quaternion result;
  VALUE vresult = Qnil;
  
  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","Ogre::Quaternion::Squad", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 5, argv[4] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::Squad", 5, argv[4])); 
  }
  arg5 = reinterpret_cast< Ogre::Quaternion * >(argp5);
  result = Ogre::Quaternion::Squad(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Quaternion const &)*arg5);
  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_Quaternion_Squad(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 == 5) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Quaternion_Squad__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Quaternion_Squad__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Quaternion.Squad", 
    "    Ogre::Quaternion Quaternion.Squad(Ogre::Real fT, Ogre::Quaternion const &rkP, Ogre::Quaternion const &rkA, Ogre::Quaternion const &rkB, Ogre::Quaternion const &rkQ, bool shortestPath)\n"
    "    Ogre::Quaternion Quaternion.Squad(Ogre::Real fT, Ogre::Quaternion const &rkP, Ogre::Quaternion const &rkA, Ogre::Quaternion const &rkB, Ogre::Quaternion const &rkQ)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_nlerp__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  bool arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::Quaternion result;
  VALUE vresult = Qnil;
  
  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","Ogre::Quaternion::nlerp", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::Quaternion::nlerp", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = Ogre::Quaternion::nlerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3,arg4);
  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_Quaternion_nlerp__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Quaternion 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Quaternion::nlerp", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Quaternion::nlerp", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  result = Ogre::Quaternion::nlerp(arg1,(Ogre::Quaternion const &)*arg2,(Ogre::Quaternion const &)*arg3);
  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_Quaternion_nlerp(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 == 3) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Quaternion_nlerp__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Quaternion_nlerp__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Quaternion.nlerp", 
    "    Ogre::Quaternion Quaternion.nlerp(Ogre::Real fT, Ogre::Quaternion const &rkP, Ogre::Quaternion const &rkQ, bool shortestPath)\n"
    "    Ogre::Quaternion Quaternion.nlerp(Ogre::Real fT, Ogre::Quaternion const &rkP, Ogre::Quaternion const &rkQ)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_msEpsilon_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Quaternion::msEpsilon));
  return _val;
}


SWIGINTERN VALUE
_wrap_Quaternion_ZERO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Quaternion::ZERO), SWIGTYPE_p_Ogre__Quaternion,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Quaternion_IDENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Quaternion::IDENTITY), SWIGTYPE_p_Ogre__Quaternion,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Quaternion_w_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","w", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","w", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->w = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_w_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","w", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->w);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_x_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","x", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->x = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_x_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->x);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_y_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","y", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->y = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_y_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->y);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_z_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","z", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->z = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_z_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->z);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Quaternion_isNaN(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = (Ogre::Quaternion *) 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_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","isNaN", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (bool)((Ogre::Quaternion const *)arg1)->isNaN();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Quaternion(Ogre::Quaternion *arg1) {
    delete arg1;
}

swig_class SwigClassVector3;

SWIGINTERN VALUE
_wrap_Vector3_x_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","x", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->x = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_x_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real) ((arg1)->x);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_y_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","y", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->y = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_y_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real) ((arg1)->y);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_z_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","z", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->z = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_z_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real) ((arg1)->z);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector3__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Vector3";
  Ogre::Vector3 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Vector3 *)new Ogre::Vector3();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector3__SWIG_1(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 = "Ogre::Vector3";
  Ogre::Vector3 *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","Ogre::Vector3", 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","Ogre::Vector3", 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","Ogre::Vector3", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Vector3 *)new Ogre::Vector3(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector3__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector3";
  Ogre::Vector3 *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real const [3]","Ogre::Vector3", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::Vector3 *)new Ogre::Vector3((Ogre::Real const (*))arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector3__SWIG_3(int argc, VALUE *argv, VALUE self) {
  int *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector3";
  Ogre::Vector3 *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_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int const [3]","Ogre::Vector3", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< int * >(argp1);
  result = (Ogre::Vector3 *)new Ogre::Vector3((int const (*))arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector3__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 = (Ogre::Real *) (Ogre::Real *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector3";
  Ogre::Vector3 *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real *const","Ogre::Vector3", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::Vector3 *)new Ogre::Vector3(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Vector3__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector3";
  Ogre::Vector3 *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","Ogre::Vector3", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Vector3 *)new Ogre::Vector3(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Vector3(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_Vector3__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector3__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector3__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector3__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_Vector3__SWIG_5(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_Vector3__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Vector3.new", 
    "    Vector3.new()\n"
    "    Vector3.new(Ogre::Real const fX, Ogre::Real const fY, Ogre::Real const fZ)\n"
    "    Vector3.new(Ogre::Real const afCoordinate[3])\n"
    "    Vector3.new(int const afCoordinate[3])\n"
    "    Vector3.new(Ogre::Real *const r)\n"
    "    Vector3.new(Ogre::Real const scaler)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_ptr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real *)(arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_ptr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real *)((Ogre::Vector3 const *)arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector3_ptr(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_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector3_ptr__SWIG_0(nargs, args, self);
    }
  }
  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_Vector3_ptr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Vector3.ptr", 
    "    Ogre::Real const * Vector3.ptr()\n"
    "    Ogre::Real const * Vector3.ptr()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Vector3.==

  call-seq:
    ==(rkVector) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Vector3___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Vector3 const *)arg1)->operator ==((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector3.+

  call-seq:
    +(rkVector) -> Vector3

Add operator.
*/
SWIGINTERN VALUE
_wrap_Vector3___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->operator +((Ogre::Vector3 const &)*arg2);
  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;
}



/*
  Document-method: Ogre::Vector3.-

  call-seq:
    -(rkVector) -> Vector3

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Vector3___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->operator -((Ogre::Vector3 const &)*arg2);
  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_Vector3___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Vector3 const *)arg1)->operator *(arg2);
  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_Vector3___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
  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_Vector3___mul__(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_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_Vector3___mul____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) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector3___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Vector3.__mul__", 
    "    Ogre::Vector3 Vector3.__mul__(Ogre::Real const fScalar)\n"
    "    Ogre::Vector3 Vector3.__mul__(Ogre::Vector3 const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3___div____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Vector3 const *)arg1)->operator /(arg2);
  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_Vector3___div____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","operator /", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator /", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->operator /((Ogre::Vector3 const &)*arg2);
  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_Vector3___div__(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_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_Vector3___div____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) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector3___div____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Vector3.__div__", 
    "    Ogre::Vector3 Vector3.__div__(Ogre::Real const fScalar)\n"
    "    Ogre::Vector3 Vector3.__div__(Ogre::Vector3 const &rhs)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Vector3.+@

  call-seq:
    +@ -> Vector3

Add operator.
*/
SWIGINTERN VALUE
_wrap_Vector3___pos__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Vector3 const *)arg1)->operator +();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector3.-@

  call-seq:
    -@ -> Vector3

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Vector3___neg__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = ((Ogre::Vector3 const *)arg1)->operator -();
  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;
}



/*
  Document-method: Ogre::Vector3.length

  call-seq:
    length -> Real

Size or Length of the Vector3.
*/
SWIGINTERN VALUE
_wrap_Vector3_length(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","length", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->length();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_squaredLength(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","squaredLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->squaredLength();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_distance(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","distance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","distance", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","distance", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->distance((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_squaredDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","squaredDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","squaredDistance", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","squaredDistance", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->squaredDistance((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_dotProduct(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","dotProduct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","dotProduct", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","dotProduct", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->dotProduct((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_absDotProduct(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","absDotProduct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","absDotProduct", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","absDotProduct", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector3 const *)arg1)->absDotProduct((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_normalise(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","normalise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Real)(arg1)->normalise();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_crossProduct(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","crossProduct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","crossProduct", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","crossProduct", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->crossProduct((Ogre::Vector3 const &)*arg2);
  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_Vector3_midPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","midPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","midPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","midPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->midPoint((Ogre::Vector3 const &)*arg2);
  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;
}



/*
  Document-method: Ogre::Vector3.<

  call-seq:
    <(rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Vector3___lt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Vector3 const *)arg1)->operator <((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector3.>

  call-seq:
    >(rhs) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap_Vector3___gt__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","operator >", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","operator >", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator >", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Vector3 const *)arg1)->operator >((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_makeFloor(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","makeFloor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","makeFloor", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","makeFloor", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->makeFloor((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_makeCeil(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 *","makeCeil", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","makeCeil", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","makeCeil", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->makeCeil((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_perpendicular(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","perpendicular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = ((Ogre::Vector3 const *)arg1)->perpendicular();
  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_Vector3_randomDeviant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","randomDeviant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 const &","randomDeviant", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","randomDeviant", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(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 &","randomDeviant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","randomDeviant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = ((Ogre::Vector3 const *)arg1)->randomDeviant((Ogre::Radian const &)*arg2,(Ogre::Vector3 const &)*arg3);
  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_Vector3_randomDeviant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","randomDeviant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 const &","randomDeviant", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","randomDeviant", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->randomDeviant((Ogre::Radian const &)*arg2);
  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_Vector3_randomDeviant(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_Ogre__Vector3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Vector3_randomDeviant__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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__Radian, 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_Vector3_randomDeviant__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.randomDeviant", 
    "    Ogre::Vector3 Vector3.randomDeviant(Ogre::Radian const &angle, Ogre::Vector3 const &up)\n"
    "    Ogre::Vector3 Vector3.randomDeviant(Ogre::Radian const &angle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_angleBetween(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Radian 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","angleBetween", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","angleBetween", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","angleBetween", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->angleBetween((Ogre::Vector3 const &)*arg2);
  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_Vector3_getRotationTo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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 ;
  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(self, &argp1,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","getRotationTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","getRotationTo", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getRotationTo", 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 &","getRotationTo", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getRotationTo", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = ((Ogre::Vector3 const *)arg1)->getRotationTo((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  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_Vector3_getRotationTo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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(self, &argp1,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","getRotationTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","getRotationTo", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getRotationTo", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Vector3 const *)arg1)->getRotationTo((Ogre::Vector3 const &)*arg2);
  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_Vector3_getRotationTo(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_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_Vector3_getRotationTo__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Vector3_getRotationTo__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.getRotationTo", 
    "    Ogre::Quaternion Vector3.getRotationTo(Ogre::Vector3 const &dest, Ogre::Vector3 const &fallbackAxis)\n"
    "    Ogre::Quaternion Vector3.getRotationTo(Ogre::Vector3 const &dest)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_isZeroLength(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","isZeroLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (bool)((Ogre::Vector3 const *)arg1)->isZeroLength();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_normalisedCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","normalisedCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = ((Ogre::Vector3 const *)arg1)->normalisedCopy();
  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_Vector3_reflect(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","reflect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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);
  result = ((Ogre::Vector3 const *)arg1)->reflect((Ogre::Vector3 const &)*arg2);
  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_Vector3_positionEquals__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","positionEquals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","positionEquals", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","positionEquals", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","positionEquals", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)((Ogre::Vector3 const *)arg1)->positionEquals((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_positionEquals__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","positionEquals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","positionEquals", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","positionEquals", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Vector3 const *)arg1)->positionEquals((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector3_positionEquals(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_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_Vector3_positionEquals__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector3_positionEquals__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.positionEquals", 
    "    bool Vector3.positionEquals(Ogre::Vector3 const &rhs, Ogre::Real tolerance)\n"
    "    bool Vector3.positionEquals(Ogre::Vector3 const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_positionCloses__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","positionCloses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","positionCloses", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","positionCloses", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","positionCloses", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)((Ogre::Vector3 const *)arg1)->positionCloses((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_positionCloses__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","positionCloses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","positionCloses", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","positionCloses", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Vector3 const *)arg1)->positionCloses((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector3_positionCloses(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_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_Vector3_positionCloses__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Vector3_positionCloses__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector3.positionCloses", 
    "    bool Vector3.positionCloses(Ogre::Vector3 const &rhs, Ogre::Real tolerance)\n"
    "    bool Vector3.positionCloses(Ogre::Vector3 const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_directionEquals(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","directionEquals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(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 &","directionEquals", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","directionEquals", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","directionEquals", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","directionEquals", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  result = (bool)((Ogre::Vector3 const *)arg1)->directionEquals((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_isNaN(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","isNaN", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (bool)((Ogre::Vector3 const *)arg1)->isNaN();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector3_primaryAxis(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","primaryAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = ((Ogre::Vector3 const *)arg1)->primaryAxis();
  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_Vector3_UNIT_X_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector3::UNIT_X), SWIGTYPE_p_Ogre__Vector3,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector3_UNIT_Y_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector3::UNIT_Y), SWIGTYPE_p_Ogre__Vector3,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector3_UNIT_Z_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector3::UNIT_Z), SWIGTYPE_p_Ogre__Vector3,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector3_NEGATIVE_UNIT_X_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector3::NEGATIVE_UNIT_X), SWIGTYPE_p_Ogre__Vector3,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector3_NEGATIVE_UNIT_Y_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector3::NEGATIVE_UNIT_Y), SWIGTYPE_p_Ogre__Vector3,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector3_NEGATIVE_UNIT_Z_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector3::NEGATIVE_UNIT_Z), SWIGTYPE_p_Ogre__Vector3,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Vector3_UNIT_SCALE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector3::UNIT_SCALE), SWIGTYPE_p_Ogre__Vector3,  0 );
  return _val;
}


SWIGINTERN void
free_Ogre_Vector3(Ogre::Vector3 *arg1) {
    delete arg1;
}

swig_class SwigClassVector4;

SWIGINTERN VALUE
_wrap_Vector4_x_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","x", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->x = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_x_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (Ogre::Real) ((arg1)->x);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_y_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","y", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->y = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_y_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (Ogre::Real) ((arg1)->y);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_z_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","z", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->z = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_z_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (Ogre::Real) ((arg1)->z);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_w_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","w", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","w", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->w = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_w_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","w", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (Ogre::Real) ((arg1)->w);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector4__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Vector4";
  Ogre::Vector4 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Vector4 *)new Ogre::Vector4();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector4__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector4";
  Ogre::Vector4 *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","Ogre::Vector4", 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","Ogre::Vector4", 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","Ogre::Vector4", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Vector4", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::Vector4 *)new Ogre::Vector4(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector4__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector4";
  Ogre::Vector4 *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real const [4]","Ogre::Vector4", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::Vector4 *)new Ogre::Vector4((Ogre::Real const (*))arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector4__SWIG_3(int argc, VALUE *argv, VALUE self) {
  int *arg1 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector4";
  Ogre::Vector4 *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_int, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "int const [4]","Ogre::Vector4", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< int * >(argp1);
  result = (Ogre::Vector4 *)new Ogre::Vector4((int const (*))arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector4__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 = (Ogre::Real *) (Ogre::Real *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector4";
  Ogre::Vector4 *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real *const","Ogre::Vector4", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::Vector4 *)new Ogre::Vector4(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Vector4__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector4";
  Ogre::Vector4 *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","Ogre::Vector4", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::Vector4 *)new Ogre::Vector4(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Vector4__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Vector4";
  Ogre::Vector4 *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__Vector3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Vector4", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Vector4", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = (Ogre::Vector4 *)new Ogre::Vector4((Ogre::Vector3 const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Vector4(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_Vector4__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector4__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_int, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector4__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Vector4__SWIG_4(nargs, args, self);
    }
  }
  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_new_Vector4__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_Vector4__SWIG_5(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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Vector4__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Vector4.new", 
    "    Vector4.new()\n"
    "    Vector4.new(Ogre::Real const fX, Ogre::Real const fY, Ogre::Real const fZ, Ogre::Real const fW)\n"
    "    Vector4.new(Ogre::Real const afCoordinate[4])\n"
    "    Vector4.new(int const afCoordinate[4])\n"
    "    Vector4.new(Ogre::Real *const r)\n"
    "    Vector4.new(Ogre::Real const scaler)\n"
    "    Vector4.new(Ogre::Vector3 const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Vector4 *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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_ptr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (Ogre::Real *)(arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_ptr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (Ogre::Real *)((Ogre::Vector4 const *)arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector4_ptr(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_Ogre__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector4_ptr__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Vector4_ptr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Vector4.ptr", 
    "    Ogre::Real const * Vector4.ptr()\n"
    "    Ogre::Real const * Vector4.ptr()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Vector4.==

  call-seq:
    ==(rkVector) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Vector4___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Vector4 *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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = (bool)((Ogre::Vector4 const *)arg1)->operator ==((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector4.+

  call-seq:
    +(rkVector) -> Vector4

Add operator.
*/
SWIGINTERN VALUE
_wrap_Vector4___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = ((Ogre::Vector4 const *)arg1)->operator +((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector4.-

  call-seq:
    -(rkVector) -> Vector4

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Vector4___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = ((Ogre::Vector4 const *)arg1)->operator -((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Vector4 const *)arg1)->operator *(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = ((Ogre::Vector4 const *)arg1)->operator *((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector4___mul__(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_Ogre__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Vector4___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector4___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Vector4.__mul__", 
    "    Ogre::Vector4 Vector4.__mul__(Ogre::Real const fScalar)\n"
    "    Ogre::Vector4 Vector4.__mul__(Ogre::Vector4 const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4___div____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Vector4 const *)arg1)->operator /(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4___div____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","operator /", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","operator /", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = ((Ogre::Vector4 const *)arg1)->operator /((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Vector4___div__(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_Ogre__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Vector4___div____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Vector4___div____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Vector4.__div__", 
    "    Ogre::Vector4 Vector4.__div__(Ogre::Real const fScalar)\n"
    "    Ogre::Vector4 Vector4.__div__(Ogre::Vector4 const &rhs)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Vector4.+@

  call-seq:
    +@ -> Vector4

Add operator.
*/
SWIGINTERN VALUE
_wrap_Vector4___pos__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 *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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (Ogre::Vector4 *) &((Ogre::Vector4 const *)arg1)->operator +();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Vector4.-@

  call-seq:
    -@ -> Vector4

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Vector4___neg__(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = ((Ogre::Vector4 const *)arg1)->operator -();
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_dotProduct(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","dotProduct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","dotProduct", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","dotProduct", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = (Ogre::Real)((Ogre::Vector4 const *)arg1)->dotProduct((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_isNaN(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = (Ogre::Vector4 *) 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_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","isNaN", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = (bool)((Ogre::Vector4 const *)arg1)->isNaN();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Vector4_ZERO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Vector4::ZERO), SWIGTYPE_p_Ogre__Vector4,  0 );
  return _val;
}


SWIGINTERN void
free_Ogre_Vector4(Ogre::Vector4 *arg1) {
    delete arg1;
}

swig_class SwigClassColourValue;

SWIGINTERN VALUE
_wrap_ColourValue_ZERO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::ColourValue::ZERO), SWIGTYPE_p_Ogre__ColourValue,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_ColourValue_Black_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::ColourValue::Black), SWIGTYPE_p_Ogre__ColourValue,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_ColourValue_White_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::ColourValue::White), SWIGTYPE_p_Ogre__ColourValue,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_ColourValue_Red_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::ColourValue::Red), SWIGTYPE_p_Ogre__ColourValue,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_ColourValue_Green_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::ColourValue::Green), SWIGTYPE_p_Ogre__ColourValue,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_ColourValue_Blue_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::ColourValue::Blue), SWIGTYPE_p_Ogre__ColourValue,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_new_ColourValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ColourValue";
  Ogre::ColourValue *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( "", "float","Ogre::ColourValue", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","Ogre::ColourValue", 2, argv[1] ));
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","Ogre::ColourValue", 3, argv[2] ));
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","Ogre::ColourValue", 4, argv[3] ));
  } 
  arg4 = static_cast< float >(val4);
  result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ColourValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ColourValue";
  Ogre::ColourValue *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( "", "float","Ogre::ColourValue", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","Ogre::ColourValue", 2, argv[1] ));
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","Ogre::ColourValue", 3, argv[2] ));
  } 
  arg3 = static_cast< float >(val3);
  result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ColourValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ColourValue";
  Ogre::ColourValue *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( "", "float","Ogre::ColourValue", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","Ogre::ColourValue", 2, argv[1] ));
  } 
  arg2 = static_cast< float >(val2);
  result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_ColourValue__SWIG_3(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ColourValue";
  Ogre::ColourValue *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( "", "float","Ogre::ColourValue", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  result = (Ogre::ColourValue *)new Ogre::ColourValue(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ColourValue__SWIG_4(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ColourValue";
  Ogre::ColourValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ColourValue *)new Ogre::ColourValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ColourValue(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_ColourValue__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_ColourValue__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_ColourValue__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_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_ColourValue__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_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_new_ColourValue__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ColourValue.new", 
    "    ColourValue.new(float red, float green, float blue, float alpha)\n"
    "    ColourValue.new(float red, float green, float blue)\n"
    "    ColourValue.new(float red, float green)\n"
    "    ColourValue.new(float red)\n"
    "    ColourValue.new()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ColourValue.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_ColourValue___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::ColourValue *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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  result = (bool)((Ogre::ColourValue const *)arg1)->operator ==((Ogre::ColourValue const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_r_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","r", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","r", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->r = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_r_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","r", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (float) ((arg1)->r);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_g_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","g", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","g", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->g = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_g_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","g", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (float) ((arg1)->g);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_b_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","b", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","b", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->b = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_b_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","b", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (float) ((arg1)->b);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_a_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","a", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","a", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  if (arg1) (arg1)->a = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_a_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","a", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (float) ((arg1)->a);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_getAsRGBA(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RGBA 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","getAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (Ogre::RGBA)((Ogre::ColourValue const *)arg1)->getAsRGBA();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_getAsARGB(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ARGB 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","getAsARGB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (Ogre::ARGB)((Ogre::ColourValue const *)arg1)->getAsARGB();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_getAsBGRA(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BGRA 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","getAsBGRA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (Ogre::BGRA)((Ogre::ColourValue const *)arg1)->getAsBGRA();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_getAsABGR(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ABGR 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","getAsABGR", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (Ogre::ABGR)((Ogre::ColourValue const *)arg1)->getAsABGR();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_setAsRGBA(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::RGBA 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","setAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::RGBA","setAsRGBA", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::RGBA >(val2);
  (arg1)->setAsRGBA(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_setAsARGB(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::ARGB 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","setAsARGB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ARGB","setAsARGB", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ARGB >(val2);
  (arg1)->setAsARGB(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_setAsBGRA(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::BGRA 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","setAsBGRA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BGRA","setAsBGRA", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BGRA >(val2);
  (arg1)->setAsBGRA(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_setAsABGR(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::ABGR 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","setAsABGR", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ABGR","setAsABGR", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ABGR >(val2);
  (arg1)->setAsABGR(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_saturate(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","saturate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  (arg1)->saturate();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_saturateCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","saturateCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = ((Ogre::ColourValue const *)arg1)->saturateCopy();
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_ptr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float *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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (float *)(arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_ptr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float *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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = (float *)((Ogre::ColourValue const *)arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ColourValue_ptr(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_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ColourValue_ptr__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ColourValue_ptr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ColourValue.ptr", 
    "    float const * ColourValue.ptr()\n"
    "    float const * ColourValue.ptr()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ColourValue.+

  call-seq:
    +(rkVector) -> ColourValue

Add operator.
*/
SWIGINTERN VALUE
_wrap_ColourValue___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ColourValue 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  result = ((Ogre::ColourValue const *)arg1)->operator +((Ogre::ColourValue const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ColourValue.-

  call-seq:
    -(rkVector) -> ColourValue

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_ColourValue___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ColourValue 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  result = ((Ogre::ColourValue const *)arg1)->operator -((Ogre::ColourValue const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  result = ((Ogre::ColourValue const *)arg1)->operator *(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ColourValue 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  result = ((Ogre::ColourValue const *)arg1)->operator *((Ogre::ColourValue const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ColourValue___mul__(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_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ColourValue___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ColourValue___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ColourValue.__mul__", 
    "    Ogre::ColourValue ColourValue.__mul__(float const fScalar)\n"
    "    Ogre::ColourValue ColourValue.__mul__(Ogre::ColourValue const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue___div____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ColourValue 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","operator /", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","operator /", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  result = ((Ogre::ColourValue const *)arg1)->operator /((Ogre::ColourValue const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue___div____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue 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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","operator /", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  result = ((Ogre::ColourValue const *)arg1)->operator /(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ColourValue___div__(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_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ColourValue___div____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ColourValue___div____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ColourValue.__div__", 
    "    Ogre::ColourValue ColourValue.__div__(Ogre::ColourValue const &rhs)\n"
    "    Ogre::ColourValue ColourValue.__div__(float const fScalar)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_setHSB(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 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 ;
  
  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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","setHSB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHSB", 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","setHSB", 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","setHSB", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setHSB(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ColourValue_getHSB(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::Real *arg2 = (Ogre::Real *) 0 ;
  Ogre::Real *arg3 = (Ogre::Real *) 0 ;
  Ogre::Real *arg4 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const *","getHSB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real *","getHSB", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real *","getHSB", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real *","getHSB", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  ((Ogre::ColourValue const *)arg1)->getHSB(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ColourValue(Ogre::ColourValue *arg1) {
    delete arg1;
}

swig_class SwigClassStringUtil;

SWIGINTERN VALUE
_wrap_StringUtil_trim__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::trim", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::trim", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::String * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::trim", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::trim", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  Ogre::StringUtil::trim(*arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_trim__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_std__string,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::trim", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::trim", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::String * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::trim", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  Ogre::StringUtil::trim(*arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_trim__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 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_std__string,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::trim", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::trim", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::String * >(argp1);
  Ogre::StringUtil::trim(*arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringUtil_trim(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__string, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringUtil_trim__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__string, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringUtil_trim__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__string, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringUtil_trim__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "StringUtil.trim", 
    "    void StringUtil.trim(Ogre::String &str, bool left, bool right)\n"
    "    void StringUtil.trim(Ogre::String &str, bool left)\n"
    "    void StringUtil.trim(Ogre::String &str)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_split__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::StringUtil::split", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::split", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::split", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::split", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Ogre::StringUtil::split", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::split", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = Ogre::StringUtil::split((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_split__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::split", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::split", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::split", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::split", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Ogre::StringUtil::split", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = Ogre::StringUtil::split((std::string const &)*arg1,(std::string const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_split__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringUtil::split", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::split", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::split", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::split", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = Ogre::StringUtil::split((std::string const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_split__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > 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( "", "Ogre::String const &","Ogre::StringUtil::split", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::split", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringUtil::split((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringUtil_split(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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringUtil_split__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringUtil_split__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringUtil_split__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringUtil_split__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StringUtil.split", 
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.split(Ogre::String const &str, Ogre::String const &delims, unsigned int maxSplits, bool preserveDelims)\n"
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.split(Ogre::String const &str, Ogre::String const &delims, unsigned int maxSplits)\n"
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.split(Ogre::String const &str, Ogre::String const &delims)\n"
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.split(Ogre::String const &str)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_tokenise__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  unsigned int arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::StringUtil::tokenise", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::tokenise", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::tokenise", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned int","Ogre::StringUtil::tokenise", 4, argv[3] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  result = Ogre::StringUtil::tokenise((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_tokenise__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::tokenise", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::tokenise", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::tokenise", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = Ogre::StringUtil::tokenise((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_tokenise__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringUtil::tokenise", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::tokenise", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = Ogre::StringUtil::tokenise((std::string const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_tokenise__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > 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( "", "Ogre::String const &","Ogre::StringUtil::tokenise", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::tokenise", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringUtil::tokenise((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type(static_cast< const Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringUtil_tokenise(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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringUtil_tokenise__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringUtil_tokenise__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringUtil_tokenise__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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) {
          {
            int res = SWIG_AsVal_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringUtil_tokenise__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StringUtil.tokenise", 
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.tokenise(Ogre::String const &str, Ogre::String const &delims, Ogre::String const &doubleDelims, unsigned int maxSplits)\n"
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.tokenise(Ogre::String const &str, Ogre::String const &delims, Ogre::String const &doubleDelims)\n"
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.tokenise(Ogre::String const &str, Ogre::String const &delims)\n"
    "    Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type StringUtil.tokenise(Ogre::String const &str)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_toLowerCase(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 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_std__string,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::toLowerCase", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::toLowerCase", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::String * >(argp1);
  Ogre::StringUtil::toLowerCase(*arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_toUpperCase(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 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_std__string,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::toUpperCase", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::toUpperCase", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::String * >(argp1);
  Ogre::StringUtil::toUpperCase(*arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_startsWith__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::startsWith", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::startsWith", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::startsWith", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::startsWith", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::startsWith", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)Ogre::StringUtil::startsWith((std::string const &)*arg1,(std::string const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_startsWith__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringUtil::startsWith", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::startsWith", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::startsWith", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::startsWith", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)Ogre::StringUtil::startsWith((std::string const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringUtil_startsWith(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 == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringUtil_startsWith__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringUtil_startsWith__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "StringUtil.startsWith", 
    "    bool StringUtil.startsWith(Ogre::String const &str, Ogre::String const &pattern, bool lowerCase)\n"
    "    bool StringUtil.startsWith(Ogre::String const &str, Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_endsWith__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::endsWith", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::endsWith", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::endsWith", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::endsWith", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::endsWith", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)Ogre::StringUtil::endsWith((std::string const &)*arg1,(std::string const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_endsWith__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringUtil::endsWith", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::endsWith", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::endsWith", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::endsWith", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)Ogre::StringUtil::endsWith((std::string const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringUtil_endsWith(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 == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringUtil_endsWith__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringUtil_endsWith__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "StringUtil.endsWith", 
    "    bool StringUtil.endsWith(Ogre::String const &str, Ogre::String const &pattern, bool lowerCase)\n"
    "    bool StringUtil.endsWith(Ogre::String const &str, Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_standardisePath(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::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( "", "Ogre::String const &","Ogre::StringUtil::standardisePath", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::standardisePath", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringUtil::standardisePath((std::string const &)*arg1);
  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_StringUtil_normalizeFilePath__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringUtil::normalizeFilePath", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::normalizeFilePath", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::normalizeFilePath", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = Ogre::StringUtil::normalizeFilePath((std::string const &)*arg1,arg2);
  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_StringUtil_normalizeFilePath__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::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( "", "Ogre::String const &","Ogre::StringUtil::normalizeFilePath", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::normalizeFilePath", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringUtil::normalizeFilePath((std::string const &)*arg1);
  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_StringUtil_normalizeFilePath(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringUtil_normalizeFilePath__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringUtil_normalizeFilePath__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringUtil.normalizeFilePath", 
    "    Ogre::String StringUtil.normalizeFilePath(Ogre::String const &init, bool makeLowerCase)\n"
    "    Ogre::String StringUtil.normalizeFilePath(Ogre::String const &init)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_splitFilename(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::splitFilename", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::splitFilename", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::splitFilename", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::splitFilename", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::splitFilename", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::splitFilename", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::String * >(argp3);
  Ogre::StringUtil::splitFilename((std::string const &)*arg1,*arg2,*arg3);
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_splitFullFilename(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::StringUtil::splitFullFilename", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::splitFullFilename", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::splitFullFilename", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::splitFullFilename", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::splitFullFilename", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::splitFullFilename", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::String * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::splitFullFilename", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::splitFullFilename", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::String * >(argp4);
  Ogre::StringUtil::splitFullFilename((std::string const &)*arg1,*arg2,*arg3,*arg4);
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_splitBaseFilename(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::splitBaseFilename", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::splitBaseFilename", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::splitBaseFilename", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::splitBaseFilename", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_std__string,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String &","Ogre::StringUtil::splitBaseFilename", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String &","Ogre::StringUtil::splitBaseFilename", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::String * >(argp3);
  Ogre::StringUtil::splitBaseFilename((std::string const &)*arg1,*arg2,*arg3);
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_match__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::match", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::match", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::match", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::match", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::StringUtil::match", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)Ogre::StringUtil::match((std::string const &)*arg1,(std::string const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_match__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringUtil::match", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::match", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::match", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::match", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (bool)Ogre::StringUtil::match((std::string const &)*arg1,(std::string const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringUtil_match(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 == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringUtil_match__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringUtil_match__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "StringUtil.match", 
    "    bool StringUtil.match(Ogre::String const &str, Ogre::String const &pattern, bool caseSensitive)\n"
    "    bool StringUtil.match(Ogre::String const &str, Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_replaceAll(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::StringUtil::replaceAll", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::replaceAll", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::replaceAll", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::replaceAll", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StringUtil::replaceAll", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringUtil::replaceAll", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = Ogre::StringUtil::replaceAll((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringUtil_BLANK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::StringUtil::BLANK));
  return _val;
}


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

SWIGINTERN VALUE
_wrap_new_StringUtil(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::StringUtil";
  Ogre::StringUtil *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::StringUtil *)new Ogre::StringUtil();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StringUtil(Ogre::StringUtil *arg1) {
    delete arg1;
}

swig_class SwigClassException;

SWIGINTERN VALUE
_wrap_new_Exception__SWIG_0(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Exception";
  Ogre::Exception *result = 0 ;
  
  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","Ogre::Exception", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Exception", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Exception", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Exception", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Exception", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Exception *)new Ogre::Exception(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Exception__SWIG_1(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  char *arg5 = (char *) 0 ;
  long arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  long val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Exception";
  Ogre::Exception *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::Exception", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Exception", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Exception", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Exception", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Exception", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::Exception", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","Ogre::Exception", 5, argv[4] ));
  }
  arg5 = reinterpret_cast< char * >(buf5);
  ecode6 = SWIG_AsVal_long(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "long","Ogre::Exception", 6, argv[5] ));
  } 
  arg6 = static_cast< long >(val6);
  result = (Ogre::Exception *)new Ogre::Exception(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,(char const *)arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Exception__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Exception";
  Ogre::Exception *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__Exception,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const &","Ogre::Exception", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Exception const &","Ogre::Exception", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (Ogre::Exception *)new Ogre::Exception((Ogre::Exception const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Exception(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Exception, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Exception__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _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_new_Exception__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            int res = SWIG_AsCharPtrAndSize(argv[4], 0, NULL, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_long(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Exception__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Exception.new", 
    "    Exception.new(int number, Ogre::String const &description, Ogre::String const &source)\n"
    "    Exception.new(int number, Ogre::String const &description, Ogre::String const &source, char const *type, char const *file, long line)\n"
    "    Exception.new(Ogre::Exception const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Exception(Ogre::Exception *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Exception_getFullDescription(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = (Ogre::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const *","getFullDescription", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getFullDescription();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_getNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = (Ogre::Exception *) 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_Ogre__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const *","getNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (int)((Ogre::Exception const *)arg1)->getNumber();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_getSource(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = (Ogre::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const *","getSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getSource();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_getFile(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = (Ogre::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const *","getFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getFile();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_getLine(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = (Ogre::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long 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_Ogre__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const *","getLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (long)((Ogre::Exception const *)arg1)->getLine();
  vresult = SWIG_From_long(static_cast< long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_getDescription(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = (Ogre::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const *","getDescription", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (Ogre::String *) &((Ogre::Exception const *)arg1)->getDescription();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Exception_what(int argc, VALUE *argv, VALUE self) {
  Ogre::Exception *arg1 = (Ogre::Exception *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *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_Ogre__Exception, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Exception const *","what", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Exception * >(argp1);
  result = (char *)((Ogre::Exception const *)arg1)->what();
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassUnimplementedException;

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

SWIGINTERN VALUE
_wrap_new_UnimplementedException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UnimplementedException";
  Ogre::UnimplementedException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::UnimplementedException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnimplementedException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnimplementedException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnimplementedException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnimplementedException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::UnimplementedException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::UnimplementedException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::UnimplementedException *)new Ogre::UnimplementedException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_UnimplementedException(Ogre::UnimplementedException *arg1) {
    delete arg1;
}

swig_class SwigClassFileNotFoundException;

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

SWIGINTERN VALUE
_wrap_new_FileNotFoundException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileNotFoundException";
  Ogre::FileNotFoundException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::FileNotFoundException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::FileNotFoundException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileNotFoundException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::FileNotFoundException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileNotFoundException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::FileNotFoundException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::FileNotFoundException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::FileNotFoundException *)new Ogre::FileNotFoundException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_FileNotFoundException(Ogre::FileNotFoundException *arg1) {
    delete arg1;
}

swig_class SwigClassIOException;

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

SWIGINTERN VALUE
_wrap_new_IOException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::IOException";
  Ogre::IOException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::IOException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::IOException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::IOException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::IOException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::IOException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::IOException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::IOException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::IOException *)new Ogre::IOException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_IOException(Ogre::IOException *arg1) {
    delete arg1;
}

swig_class SwigClassInvalidStateException;

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

SWIGINTERN VALUE
_wrap_new_InvalidStateException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::InvalidStateException";
  Ogre::InvalidStateException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::InvalidStateException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InvalidStateException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InvalidStateException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InvalidStateException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InvalidStateException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::InvalidStateException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::InvalidStateException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::InvalidStateException *)new Ogre::InvalidStateException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InvalidStateException(Ogre::InvalidStateException *arg1) {
    delete arg1;
}

swig_class SwigClassInvalidParametersException;

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

SWIGINTERN VALUE
_wrap_new_InvalidParametersException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::InvalidParametersException";
  Ogre::InvalidParametersException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::InvalidParametersException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InvalidParametersException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InvalidParametersException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InvalidParametersException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InvalidParametersException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::InvalidParametersException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::InvalidParametersException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::InvalidParametersException *)new Ogre::InvalidParametersException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InvalidParametersException(Ogre::InvalidParametersException *arg1) {
    delete arg1;
}

swig_class SwigClassItemIdentityException;

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

SWIGINTERN VALUE
_wrap_new_ItemIdentityException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ItemIdentityException";
  Ogre::ItemIdentityException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::ItemIdentityException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ItemIdentityException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ItemIdentityException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ItemIdentityException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ItemIdentityException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ItemIdentityException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ItemIdentityException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::ItemIdentityException *)new Ogre::ItemIdentityException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_ItemIdentityException(Ogre::ItemIdentityException *arg1) {
    delete arg1;
}

swig_class SwigClassInternalErrorException;

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

SWIGINTERN VALUE
_wrap_new_InternalErrorException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::InternalErrorException";
  Ogre::InternalErrorException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::InternalErrorException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InternalErrorException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InternalErrorException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InternalErrorException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InternalErrorException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::InternalErrorException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::InternalErrorException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::InternalErrorException *)new Ogre::InternalErrorException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InternalErrorException(Ogre::InternalErrorException *arg1) {
    delete arg1;
}

swig_class SwigClassRenderingAPIException;

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

SWIGINTERN VALUE
_wrap_new_RenderingAPIException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderingAPIException";
  Ogre::RenderingAPIException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::RenderingAPIException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::RenderingAPIException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RenderingAPIException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::RenderingAPIException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RenderingAPIException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::RenderingAPIException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::RenderingAPIException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::RenderingAPIException *)new Ogre::RenderingAPIException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderingAPIException(Ogre::RenderingAPIException *arg1) {
    delete arg1;
}

swig_class SwigClassRuntimeAssertionException;

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

SWIGINTERN VALUE
_wrap_new_RuntimeAssertionException(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RuntimeAssertionException";
  Ogre::RuntimeAssertionException *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::RuntimeAssertionException", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::RuntimeAssertionException", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RuntimeAssertionException", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::RuntimeAssertionException", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RuntimeAssertionException", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::RuntimeAssertionException", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::RuntimeAssertionException", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = (Ogre::RuntimeAssertionException *)new Ogre::RuntimeAssertionException(arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(char const *)arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN void
free_Ogre_RuntimeAssertionException(Ogre::RuntimeAssertionException *arg1) {
    delete arg1;
}

swig_class SwigClassExceptionFactory;

SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_NOT_IMPLEMENTED > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::UnimplementedException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_NOT_IMPLEMENTED >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_NOT_IMPLEMENTED >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_NOT_IMPLEMENTED > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::UnimplementedException(static_cast< const Ogre::UnimplementedException& >(result))), SWIGTYPE_p_Ogre__UnimplementedException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_1(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_FILE_NOT_FOUND > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::FileNotFoundException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_FILE_NOT_FOUND >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_FILE_NOT_FOUND >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_FILE_NOT_FOUND > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::FileNotFoundException(static_cast< const Ogre::FileNotFoundException& >(result))), SWIGTYPE_p_Ogre__FileNotFoundException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_2(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::IOException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::IOException(static_cast< const Ogre::IOException& >(result))), SWIGTYPE_p_Ogre__IOException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_3(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALID_STATE > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::InvalidStateException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALID_STATE >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALID_STATE >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALID_STATE > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::InvalidStateException(static_cast< const Ogre::InvalidStateException& >(result))), SWIGTYPE_p_Ogre__InvalidStateException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_4(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALIDPARAMS > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::InvalidParametersException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALIDPARAMS >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALIDPARAMS >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALIDPARAMS > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::InvalidParametersException(static_cast< const Ogre::InvalidParametersException& >(result))), SWIGTYPE_p_Ogre__InvalidParametersException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_5(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_ITEM_NOT_FOUND > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::ItemIdentityException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_ITEM_NOT_FOUND >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_ITEM_NOT_FOUND >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_ITEM_NOT_FOUND > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ItemIdentityException(static_cast< const Ogre::ItemIdentityException& >(result))), SWIGTYPE_p_Ogre__ItemIdentityException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_6(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_DUPLICATE_ITEM > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::ItemIdentityException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_DUPLICATE_ITEM >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_DUPLICATE_ITEM >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_DUPLICATE_ITEM > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ItemIdentityException(static_cast< const Ogre::ItemIdentityException& >(result))), SWIGTYPE_p_Ogre__ItemIdentityException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_7(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_INTERNAL_ERROR > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::InternalErrorException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INTERNAL_ERROR >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INTERNAL_ERROR >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_INTERNAL_ERROR > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::InternalErrorException(static_cast< const Ogre::InternalErrorException& >(result))), SWIGTYPE_p_Ogre__InternalErrorException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_8(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_RENDERINGAPI_ERROR > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::RenderingAPIException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_RENDERINGAPI_ERROR >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_RENDERINGAPI_ERROR >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_RENDERINGAPI_ERROR > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::RenderingAPIException(static_cast< const Ogre::RenderingAPIException& >(result))), SWIGTYPE_p_Ogre__RenderingAPIException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExceptionFactory_create__SWIG_9(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ExceptionCodeType< Ogre::Exception::ERR_RT_ASSERTION_FAILED > > arg1 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  char *arg4 = (char *) 0 ;
  long arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  long val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::RuntimeAssertionException > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_RT_ASSERTION_FAILED >","Ogre::ExceptionFactory::create", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_RT_ASSERTION_FAILED >","Ogre::ExceptionFactory::create", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::ExceptionCodeType< Ogre::Exception::ERR_RT_ASSERTION_FAILED > * >(argp1));
    }
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ExceptionFactory::create", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::ExceptionFactory::create", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_long(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "long","Ogre::ExceptionFactory::create", 5, argv[4] ));
  } 
  arg5 = static_cast< long >(val5);
  result = Ogre::ExceptionFactory::create(arg1,(std::string const &)*arg2,(std::string const &)*arg3,(char const *)arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::RuntimeAssertionException(static_cast< const Ogre::RuntimeAssertionException& >(result))), SWIGTYPE_p_Ogre__RuntimeAssertionException, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ExceptionFactory_create(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 == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_7(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_8(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_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) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_long(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ExceptionFactory_create__SWIG_9(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ExceptionFactory.create", 
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_NOT_IMPLEMENTED > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_FILE_NOT_FOUND > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALID_STATE > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALIDPARAMS > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_ITEM_NOT_FOUND > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_DUPLICATE_ITEM > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_INTERNAL_ERROR > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_RENDERINGAPI_ERROR > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n"
    "    Ogre::RuntimeAssertionException ExceptionFactory.create(Ogre::ExceptionCodeType< Ogre::Exception::ERR_RT_ASSERTION_FAILED > code, Ogre::String const &desc, Ogre::String const &src, char const *file, long line)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_ExceptionFactory(Ogre::ExceptionFactory *arg1) {
    delete arg1;
}

swig_class SwigClassAny;

SWIGINTERN VALUE
_wrap_new_Any__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Any";
  Ogre::Any *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Any *)new Ogre::Any();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Any__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Any *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Any";
  Ogre::Any *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__Any,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Any const &","Ogre::Any", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","Ogre::Any", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Any * >(argp1);
  result = (Ogre::Any *)new Ogre::Any((Ogre::Any const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Any(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_Any__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Any, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Any__SWIG_2(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Any.new", 
    "    Any.new()\n"
    "    Any.new(Ogre::Any const &other)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Any(Ogre::Any *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Any_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::Any *arg1 = (Ogre::Any *) 0 ;
  Ogre::Any *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::Any *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_Ogre__Any, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Any *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Any * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  result = (Ogre::Any *) &(arg1)->swap(*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Any_isEmpty(int argc, VALUE *argv, VALUE self) {
  Ogre::Any *arg1 = (Ogre::Any *) 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_Ogre__Any, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Any const *","isEmpty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Any * >(argp1);
  result = (bool)((Ogre::Any const *)arg1)->isEmpty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Any_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::Any *arg1 = (Ogre::Any *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::type_info *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_Ogre__Any, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Any const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Any * >(argp1);
  result = (std::type_info *) &((Ogre::Any const *)arg1)->getType();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__type_info, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Any_destroy(int argc, VALUE *argv, VALUE self) {
  Ogre::Any *arg1 = (Ogre::Any *) 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_Ogre__Any, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Any *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Any * >(argp1);
  (arg1)->destroy();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Any_toVALUE(int argc, VALUE *argv, VALUE self) {
  Ogre::Any *arg1 = (Ogre::Any *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnyVALUE *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_Ogre__Any, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Any *","toVALUE", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Any * >(argp1);
  result = (Ogre::AnyVALUE *)Ogre_Any_toVALUE(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnyVALUE, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassAnyNumeric;

SWIGINTERN VALUE
_wrap_new_AnyNumeric__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::AnyNumeric";
  Ogre::AnyNumeric *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::AnyNumeric *)new Ogre::AnyNumeric();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_AnyNumeric__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyNumeric *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnyNumeric";
  Ogre::AnyNumeric *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__AnyNumeric,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const &","Ogre::AnyNumeric", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnyNumeric const &","Ogre::AnyNumeric", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::AnyNumeric * >(argp1);
  result = (Ogre::AnyNumeric *)new Ogre::AnyNumeric((Ogre::AnyNumeric const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AnyNumeric(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_AnyNumeric__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnyNumeric, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnyNumeric__SWIG_2(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AnyNumeric.new", 
    "    AnyNumeric.new()\n"
    "    AnyNumeric.new(Ogre::AnyNumeric const &other)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AnyNumeric.+

  call-seq:
    +(rhs) -> AnyNumeric

Add operator.
*/
SWIGINTERN VALUE
_wrap_AnyNumeric___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyNumeric *arg1 = (Ogre::AnyNumeric *) 0 ;
  Ogre::AnyNumeric *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::AnyNumeric 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_Ogre__AnyNumeric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnyNumeric * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnyNumeric,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnyNumeric const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnyNumeric * >(argp2);
  result = ((Ogre::AnyNumeric const *)arg1)->operator +((Ogre::AnyNumeric const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::AnyNumeric(static_cast< const Ogre::AnyNumeric& >(result))), SWIGTYPE_p_Ogre__AnyNumeric, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnyNumeric.-

  call-seq:
    -(rhs) -> AnyNumeric

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_AnyNumeric___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyNumeric *arg1 = (Ogre::AnyNumeric *) 0 ;
  Ogre::AnyNumeric *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::AnyNumeric 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_Ogre__AnyNumeric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnyNumeric * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnyNumeric,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnyNumeric const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnyNumeric * >(argp2);
  result = ((Ogre::AnyNumeric const *)arg1)->operator -((Ogre::AnyNumeric const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::AnyNumeric(static_cast< const Ogre::AnyNumeric& >(result))), SWIGTYPE_p_Ogre__AnyNumeric, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnyNumeric___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyNumeric *arg1 = (Ogre::AnyNumeric *) 0 ;
  Ogre::AnyNumeric *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::AnyNumeric 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_Ogre__AnyNumeric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnyNumeric * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnyNumeric,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnyNumeric const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnyNumeric * >(argp2);
  result = ((Ogre::AnyNumeric const *)arg1)->operator *((Ogre::AnyNumeric const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::AnyNumeric(static_cast< const Ogre::AnyNumeric& >(result))), SWIGTYPE_p_Ogre__AnyNumeric, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnyNumeric___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyNumeric *arg1 = (Ogre::AnyNumeric *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::AnyNumeric 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_Ogre__AnyNumeric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnyNumeric * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::AnyNumeric const *)arg1)->operator *(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::AnyNumeric(static_cast< const Ogre::AnyNumeric& >(result))), SWIGTYPE_p_Ogre__AnyNumeric, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnyNumeric___mul__(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_Ogre__AnyNumeric, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AnyNumeric, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnyNumeric___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnyNumeric, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnyNumeric___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AnyNumeric.__mul__", 
    "    Ogre::AnyNumeric AnyNumeric.__mul__(Ogre::AnyNumeric const &rhs)\n"
    "    Ogre::AnyNumeric AnyNumeric.__mul__(Ogre::Real factor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnyNumeric___div__(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyNumeric *arg1 = (Ogre::AnyNumeric *) 0 ;
  Ogre::AnyNumeric *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::AnyNumeric 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_Ogre__AnyNumeric, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const *","operator /", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnyNumeric * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnyNumeric,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const &","operator /", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnyNumeric const &","operator /", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnyNumeric * >(argp2);
  result = ((Ogre::AnyNumeric const *)arg1)->operator /((Ogre::AnyNumeric const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::AnyNumeric(static_cast< const Ogre::AnyNumeric& >(result))), SWIGTYPE_p_Ogre__AnyNumeric, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnyNumeric(Ogre::AnyNumeric *arg1) {
    delete arg1;
}

swig_class SwigClassAnyVALUE;

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

SWIGINTERN VALUE
_wrap_new_AnyVALUE(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::AnyVALUE";
  Ogre::AnyVALUE *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::AnyVALUE *)new Ogre::AnyVALUE();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnyVALUE_setVALUE(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyVALUE *arg1 = (Ogre::AnyVALUE *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 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_Ogre__AnyVALUE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyVALUE *","setVALUE", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnyVALUE * >(argp1);
  arg2 = argv[0];
  (arg1)->setVALUE(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnyVALUE_getVALUE(int argc, VALUE *argv, VALUE self) {
  Ogre::AnyVALUE *arg1 = (Ogre::AnyVALUE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_Ogre__AnyVALUE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnyVALUE *","getVALUE", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnyVALUE * >(argp1);
  result = (VALUE)(arg1)->getVALUE();
  vresult = result;
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnyVALUE(Ogre::AnyVALUE *arg1) {
    delete arg1;
}

swig_class SwigClassAnimableValue;

SWIGINTERN void
free_Ogre_AnimableValue(Ogre::AnimableValue *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AnimableValue_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimableValue::ValueType 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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  result = (Ogre::AnimableValue::ValueType)((Ogre::AnimableValue const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setCurrentStateAsBaseValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setCurrentStateAsBaseValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  (arg1)->setCurrentStateAsBaseValue();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Vector2 *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->setValue((Ogre::Vector2 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Vector3 *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setValue((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Vector4 *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  (arg1)->setValue((Ogre::Vector4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Quaternion *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->setValue((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::ColourValue *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setValue((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Radian *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 const &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setValue((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Degree *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  (arg1)->setValue((Ogre::Degree const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_setValue__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Any *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  (arg1)->setValue((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimableValue_setValue(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_Ogre__AnimableValue, 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_AnimableValue_setValue__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 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_AnimableValue_setValue__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Any, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_9(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnimableValue_setValue__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AnimableValue.setValue", 
    "    void AnimableValue.setValue(int)\n"
    "    void AnimableValue.setValue(Ogre::Real)\n"
    "    void AnimableValue.setValue(Ogre::Vector2 const &)\n"
    "    void AnimableValue.setValue(Ogre::Vector3 const &)\n"
    "    void AnimableValue.setValue(Ogre::Vector4 const &)\n"
    "    void AnimableValue.setValue(Ogre::Quaternion const &)\n"
    "    void AnimableValue.setValue(Ogre::ColourValue const &)\n"
    "    void AnimableValue.setValue(Ogre::Radian const &)\n"
    "    void AnimableValue.setValue(Ogre::Degree const &)\n"
    "    void AnimableValue.setValue(Ogre::Any const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_resetToBaseValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","resetToBaseValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  (arg1)->resetToBaseValue();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","applyDeltaValue", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->applyDeltaValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","applyDeltaValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->applyDeltaValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Vector2 *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->applyDeltaValue((Ogre::Vector2 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Vector3 *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->applyDeltaValue((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Vector4 *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  (arg1)->applyDeltaValue((Ogre::Vector4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Quaternion *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->applyDeltaValue((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::ColourValue *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->applyDeltaValue((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Degree *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree const &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Degree * >(argp2);
  (arg1)->applyDeltaValue((Ogre::Degree const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Radian *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(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 const &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->applyDeltaValue((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableValue_applyDeltaValue__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableValue *arg1 = (Ogre::AnimableValue *) 0 ;
  Ogre::Any *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_Ogre__AnimableValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableValue *","applyDeltaValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","applyDeltaValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","applyDeltaValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  (arg1)->applyDeltaValue((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimableValue_applyDeltaValue(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_Ogre__AnimableValue, 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_AnimableValue_applyDeltaValue__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 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_AnimableValue_applyDeltaValue__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Any, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_9(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimableValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnimableValue_applyDeltaValue__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AnimableValue.applyDeltaValue", 
    "    void AnimableValue.applyDeltaValue(int)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Real)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Vector2 const &)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Vector3 const &)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Vector4 const &)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Quaternion const &)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::ColourValue const &)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Degree const &)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Radian const &)\n"
    "    void AnimableValue.applyDeltaValue(Ogre::Any const &val)\n");
  
  return Qnil;
}


swig_class SwigClassAnimableObject;

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

SWIGINTERN VALUE
_wrap_new_AnimableObject(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::AnimableObject";
  Ogre::AnimableObject *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::AnimableObject *)new Ogre::AnimableObject();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimableObject(Ogre::AnimableObject *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AnimableObject_getAnimableValueNames(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableObject *arg1 = (Ogre::AnimableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__AnimableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableObject const *","getAnimableValueNames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableObject * >(argp1);
  result = (Ogre::StringVector *) &((Ogre::AnimableObject const *)arg1)->getAnimableValueNames();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimableObject_createAnimableValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimableObject *arg1 = (Ogre::AnimableObject *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::AnimableValue > > 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_Ogre__AnimableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimableObject *","createAnimableValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimableObject * >(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( "", "Ogre::String const &","createAnimableValue", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimableValue", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->createAnimableValue((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::AnimableValuePtr(static_cast< const Ogre::AnimableValuePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassMatrix3;

SWIGINTERN VALUE
_wrap_new_Matrix3__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Matrix3";
  Ogre::Matrix3 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Matrix3 *)new Ogre::Matrix3();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Matrix3__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real (*arg1)[3] ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Matrix3";
  Ogre::Matrix3 *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_a_3__float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real const [3][3]","Ogre::Matrix3", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< Ogre::Real (*)[3] >(argp1);
  result = (Ogre::Matrix3 *)new Ogre::Matrix3((Ogre::Real const (*)[3])arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Matrix3__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Matrix3";
  Ogre::Matrix3 *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__Matrix3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","Ogre::Matrix3", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","Ogre::Matrix3", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = (Ogre::Matrix3 *)new Ogre::Matrix3((Ogre::Matrix3 const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Matrix3__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Real arg8 ;
  Ogre::Real arg9 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Matrix3";
  Ogre::Matrix3 *result = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",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","Ogre::Matrix3", 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","Ogre::Matrix3", 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","Ogre::Matrix3", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix3", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix3", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix3", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix3", 7, argv[6] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_float(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix3", 8, argv[7] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_float(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix3", 9, argv[8] ));
  } 
  arg9 = static_cast< Ogre::Real >(val9);
  result = (Ogre::Matrix3 *)new Ogre::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Matrix3(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs;
  if (argc > 9) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Matrix3__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_a_3__float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix3__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix3__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 9) {
    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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_Matrix3__SWIG_3(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "Matrix3.new", 
    "    Matrix3.new()\n"
    "    Matrix3.new(Ogre::Real const arr[3][3])\n"
    "    Matrix3.new(Ogre::Matrix3 const &rkMatrix)\n"
    "    Matrix3.new(Ogre::Real fEntry00, Ogre::Real fEntry01, Ogre::Real fEntry02, Ogre::Real fEntry10, Ogre::Real fEntry11, Ogre::Real fEntry12, Ogre::Real fEntry20, Ogre::Real fEntry21, Ogre::Real fEntry22)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_GetColumn(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","GetColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","GetColumn", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::Matrix3 const *)arg1)->GetColumn(arg2);
  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_Matrix3_SetColumn(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 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 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","SetColumn", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","SetColumn", 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 &","SetColumn", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","SetColumn", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->SetColumn(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromAxes(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 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 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromAxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","FromAxes", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAxes", 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 &","FromAxes", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAxes", 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 &","FromAxes", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAxes", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->FromAxes((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix3.==

  call-seq:
    ==(rkMatrix) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Matrix3___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  result = (bool)((Ogre::Matrix3 const *)arg1)->operator ==((Ogre::Matrix3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix3.+

  call-seq:
    +(rkMatrix) -> Matrix3

Add operator.
*/
SWIGINTERN VALUE
_wrap_Matrix3___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  result = ((Ogre::Matrix3 const *)arg1)->operator +((Ogre::Matrix3 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix3.-

  call-seq:
    -(rkMatrix) -> Matrix3

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Matrix3___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  result = ((Ogre::Matrix3 const *)arg1)->operator -((Ogre::Matrix3 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  result = ((Ogre::Matrix3 const *)arg1)->operator *((Ogre::Matrix3 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix3.-@

  call-seq:
    -@ -> Matrix3

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Matrix3___neg__(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = ((Ogre::Matrix3 const *)arg1)->operator -();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Matrix3 const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
  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_Matrix3___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Matrix3 const *)arg1)->operator *(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix3___mul__(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_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix3___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 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_Matrix3___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix3___mul____SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix3.__mul__", 
    "    Ogre::Matrix3 Matrix3.__mul__(Ogre::Matrix3 const &rkMatrix)\n"
    "    Ogre::Matrix3 Matrix3.__mul__(Ogre::Vector3 const &rkVector)\n"
    "    Ogre::Matrix3 Matrix3.__mul__(Ogre::Real fScalar)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_Transpose(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","Transpose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = ((Ogre::Matrix3 const *)arg1)->Transpose();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_Inverse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","Inverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","Inverse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","Inverse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Inverse", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)((Ogre::Matrix3 const *)arg1)->Inverse(*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_Inverse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","Inverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","Inverse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","Inverse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  result = (bool)((Ogre::Matrix3 const *)arg1)->Inverse(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_Inverse__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","Inverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Inverse", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Matrix3 const *)arg1)->Inverse(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_Inverse__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix3 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","Inverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = ((Ogre::Matrix3 const *)arg1)->Inverse();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix3_Inverse(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_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Matrix3_Inverse__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix3_Inverse__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix3_Inverse__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Matrix3_Inverse__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Matrix3.Inverse", 
    "    Ogre::Matrix3 Matrix3.Inverse(Ogre::Matrix3 &rkInverse, Ogre::Real fTolerance)\n"
    "    Ogre::Matrix3 Matrix3.Inverse(Ogre::Matrix3 &rkInverse)\n"
    "    Ogre::Matrix3 Matrix3.Inverse(Ogre::Real fTolerance)\n"
    "    Ogre::Matrix3 Matrix3.Inverse()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_Determinant(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","Determinant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = (Ogre::Real)((Ogre::Matrix3 const *)arg1)->Determinant();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_SingularValueDecomposition(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Matrix3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","SingularValueDecomposition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","SingularValueDecomposition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","SingularValueDecomposition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(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 &","SingularValueDecomposition", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","SingularValueDecomposition", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","SingularValueDecomposition", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","SingularValueDecomposition", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Matrix3 * >(argp4);
  ((Ogre::Matrix3 const *)arg1)->SingularValueDecomposition(*arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_SingularValueComposition(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Matrix3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","SingularValueComposition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","SingularValueComposition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","SingularValueComposition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(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 &","SingularValueComposition", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","SingularValueComposition", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","SingularValueComposition", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","SingularValueComposition", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Matrix3 * >(argp4);
  (arg1)->SingularValueComposition((Ogre::Matrix3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Matrix3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_Orthonormalize(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","Orthonormalize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  (arg1)->Orthonormalize();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_QDUDecomposition(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","QDUDecomposition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","QDUDecomposition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","QDUDecomposition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(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 &","QDUDecomposition", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","QDUDecomposition", 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 &","QDUDecomposition", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","QDUDecomposition", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  ((Ogre::Matrix3 const *)arg1)->QDUDecomposition(*arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_SpectralNorm(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","SpectralNorm", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = (Ogre::Real)((Ogre::Matrix3 const *)arg1)->SpectralNorm();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToAngleAxis__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Radian *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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToAngleAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToAngleAxis", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","ToAngleAxis", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian &","ToAngleAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToAngleAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  ((Ogre::Matrix3 const *)arg1)->ToAngleAxis(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToAngleAxis__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Degree *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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToAngleAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToAngleAxis", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","ToAngleAxis", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Degree,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Degree &","ToAngleAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree &","ToAngleAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Degree * >(argp3);
  ((Ogre::Matrix3 const *)arg1)->ToAngleAxis(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix3_ToAngleAxis(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 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__Radian, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Matrix3_ToAngleAxis__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 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__Degree, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Matrix3_ToAngleAxis__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Matrix3.ToAngleAxis", 
    "    void Matrix3.ToAngleAxis(Ogre::Vector3 &rkAxis, Ogre::Radian &rfAngle)\n"
    "    void Matrix3.ToAngleAxis(Ogre::Vector3 &rkAxis, Ogre::Degree &rfAngle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromAngleAxis(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Radian *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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromAngleAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","FromAngleAxis", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","FromAngleAxis", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromAngleAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromAngleAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  (arg1)->FromAngleAxis((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToEulerAnglesXYZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToEulerAnglesXYZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToEulerAnglesXYZ", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesXYZ", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesXYZ", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesXYZ", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesXYZ", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesXYZ", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesXYZ(*arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToEulerAnglesXZY(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToEulerAnglesXZY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToEulerAnglesXZY", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesXZY", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesXZY", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesXZY", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesXZY", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesXZY", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesXZY(*arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToEulerAnglesYXZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToEulerAnglesYXZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToEulerAnglesYXZ", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesYXZ", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesYXZ", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesYXZ", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesYXZ", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesYXZ", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesYXZ(*arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToEulerAnglesYZX(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToEulerAnglesYZX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToEulerAnglesYZX", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesYZX", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesYZX", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesYZX", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesYZX", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesYZX", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesYZX(*arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToEulerAnglesZXY(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToEulerAnglesZXY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToEulerAnglesZXY", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesZXY", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesZXY", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesZXY", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesZXY", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesZXY", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesZXY(*arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_ToEulerAnglesZYX(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","ToEulerAnglesZYX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 &","ToEulerAnglesZYX", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesZYX", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesZYX", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesZYX", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian &","ToEulerAnglesZYX", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian &","ToEulerAnglesZYX", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  result = (bool)((Ogre::Matrix3 const *)arg1)->ToEulerAnglesZYX(*arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromEulerAnglesXYZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromEulerAnglesXYZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 const &","FromEulerAnglesXYZ", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesXYZ", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesXYZ", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesXYZ", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesXYZ", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesXYZ", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  (arg1)->FromEulerAnglesXYZ((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromEulerAnglesXZY(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromEulerAnglesXZY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 const &","FromEulerAnglesXZY", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesXZY", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesXZY", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesXZY", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesXZY", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesXZY", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  (arg1)->FromEulerAnglesXZY((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromEulerAnglesYXZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromEulerAnglesYXZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 const &","FromEulerAnglesYXZ", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesYXZ", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesYXZ", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesYXZ", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesYXZ", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesYXZ", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  (arg1)->FromEulerAnglesYXZ((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromEulerAnglesYZX(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromEulerAnglesYZX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 const &","FromEulerAnglesYZX", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesYZX", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesYZX", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesYZX", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesYZX", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesYZX", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  (arg1)->FromEulerAnglesYZX((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromEulerAnglesZXY(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromEulerAnglesZXY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 const &","FromEulerAnglesZXY", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesZXY", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesZXY", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesZXY", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesZXY", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesZXY", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  (arg1)->FromEulerAnglesZXY((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_FromEulerAnglesZYX(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Radian *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","FromEulerAnglesZYX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(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 const &","FromEulerAnglesZYX", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesZYX", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesZYX", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesZYX", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian const &","FromEulerAnglesZYX", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","FromEulerAnglesZYX", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Radian * >(argp4);
  (arg1)->FromEulerAnglesZYX((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,(Ogre::Radian const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_EigenSolveSymmetric(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 0 ;
  Ogre::Real *arg2 ;
  Ogre::Vector3 *arg3 ;
  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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","EigenSolveSymmetric", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real [3]","EigenSolveSymmetric", 2, argv[0] )); 
  } 
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 [3]","EigenSolveSymmetric", 3, argv[1] )); 
  } 
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ((Ogre::Matrix3 const *)arg1)->EigenSolveSymmetric(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_TensorProduct(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Matrix3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Matrix3::TensorProduct", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Matrix3::TensorProduct", 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 &","Ogre::Matrix3::TensorProduct", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Matrix3::TensorProduct", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","Ogre::Matrix3::TensorProduct", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","Ogre::Matrix3::TensorProduct", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix3 * >(argp3);
  Ogre::Matrix3::TensorProduct((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_hasScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = (Ogre::Matrix3 *) 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_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","hasScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = (bool)((Ogre::Matrix3 const *)arg1)->hasScale();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix3_EPSILON_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Matrix3::EPSILON));
  return _val;
}


SWIGINTERN VALUE
_wrap_Matrix3_ZERO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Matrix3::ZERO), SWIGTYPE_p_Ogre__Matrix3,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Matrix3_IDENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Matrix3::IDENTITY), SWIGTYPE_p_Ogre__Matrix3,  0 );
  return _val;
}


SWIGINTERN void
free_Ogre_Matrix3(Ogre::Matrix3 *arg1) {
    delete arg1;
}

swig_class SwigClassPlane;

SWIGINTERN VALUE
_wrap_new_Plane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Plane";
  Ogre::Plane *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Plane *)new Ogre::Plane();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Plane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Plane";
  Ogre::Plane *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__Plane,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const &","Ogre::Plane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","Ogre::Plane", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  result = (Ogre::Plane *)new Ogre::Plane((Ogre::Plane const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Plane__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Plane";
  Ogre::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 &","Ogre::Plane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Plane", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Plane", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Plane *)new Ogre::Plane((Ogre::Vector3 const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Plane__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Plane";
  Ogre::Plane *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","Ogre::Plane", 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","Ogre::Plane", 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","Ogre::Plane", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Plane", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::Plane *)new Ogre::Plane(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Plane__SWIG_4(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 = "Ogre::Plane";
  Ogre::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 &","Ogre::Plane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::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 &","Ogre::Plane", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Plane", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Plane *)new Ogre::Plane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
  DATA_PTR(self) = result;
  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_Ogre__Plane);
#ifndef HAVE_RB_DEFINE_ALLOC_FUNC
    rb_obj_call_init(vresult, argc, argv);
#endif
    return vresult;
  }
  

SWIGINTERN VALUE
_wrap_new_Plane__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Plane";
  Ogre::Plane *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Plane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::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 &","Ogre::Plane", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Plane", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::Plane", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Plane", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = (Ogre::Plane *)new Ogre::Plane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Plane(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_Plane__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Plane__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_new_Plane__SWIG_4(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) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Plane__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Plane__SWIG_5(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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Plane__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Plane.new", 
    "    Plane.new()\n"
    "    Plane.new(Ogre::Plane const &rhs)\n"
    "    Plane.new(Ogre::Vector3 const &rkNormal, Ogre::Real fConstant)\n"
    "    Plane.new(Ogre::Real a, Ogre::Real b, Ogre::Real c, Ogre::Real d)\n"
    "    Plane.new(Ogre::Vector3 const &rkNormal, Ogre::Vector3 const &rkPoint)\n"
    "    Plane.new(Ogre::Vector3 const &rkPoint0, Ogre::Vector3 const &rkPoint1, Ogre::Vector3 const &rkPoint2)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_getSide__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Plane::Side 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const *","getSide", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(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 &","getSide", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getSide", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Plane::Side)((Ogre::Plane const *)arg1)->getSide((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_getSide__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Plane::Side 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const *","getSide", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","getSide", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","getSide", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (Ogre::Plane::Side)((Ogre::Plane const *)arg1)->getSide((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_getSide__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 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 ;
  Ogre::Plane::Side 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const *","getSide", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(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 &","getSide", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getSide", 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 &","getSide", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getSide", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = (Ogre::Plane::Side)((Ogre::Plane const *)arg1)->getSide((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Plane_getSide(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_Ogre__Plane, 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_Plane_getSide__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Plane_getSide__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Plane, 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_Plane_getSide__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Plane.getSide", 
    "    Ogre::Plane::Side Plane.getSide(Ogre::Vector3 const &rkPoint)\n"
    "    Ogre::Plane::Side Plane.getSide(Ogre::AxisAlignedBox const &rkBox)\n"
    "    Ogre::Plane::Side Plane.getSide(Ogre::Vector3 const &centre, Ogre::Vector3 const &halfSize)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_getDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const *","getDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(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 &","getDistance", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getDistance", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Real)((Ogre::Plane const *)arg1)->getDistance((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_redefine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 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 ;
  
  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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane *","redefine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(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 &","redefine", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","redefine", 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 &","redefine", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","redefine", 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 &","redefine", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","redefine", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->redefine((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_redefine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane *","redefine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(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 &","redefine", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","redefine", 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 &","redefine", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","redefine", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->redefine((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Plane_redefine(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_Ogre__Plane, 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_Plane_redefine__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Plane, 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_Plane_redefine__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Plane.redefine", 
    "    void Plane.redefine(Ogre::Vector3 const &rkPoint0, Ogre::Vector3 const &rkPoint1, Ogre::Vector3 const &rkPoint2)\n"
    "    void Plane.redefine(Ogre::Vector3 const &rkNormal, Ogre::Vector3 const &rkPoint)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_projectVector(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const *","projectVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(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 &","projectVector", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","projectVector", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Plane const *)arg1)->projectVector((Ogre::Vector3 const &)*arg2);
  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_Plane_normalise(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane *","normalise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  result = (Ogre::Real)(arg1)->normalise();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_normal_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane *","normal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","normal", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  if (arg1) (arg1)->normal = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_normal_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane *","normal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  result = (Ogre::Vector3 *)& ((arg1)->normal);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_d_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane *","d", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","d", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->d = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plane_d_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane *","d", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  result = (Ogre::Real) ((arg1)->d);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Plane.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Plane___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = (Ogre::Plane *) 0 ;
  Ogre::Plane *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_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  result = (bool)((Ogre::Plane const *)arg1)->operator ==((Ogre::Plane const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Plane(Ogre::Plane *arg1) {
    delete arg1;
}

swig_class SwigClassMatrix4;

SWIGINTERN VALUE
_wrap_new_Matrix4__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Matrix4";
  Ogre::Matrix4 *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Matrix4 *)new Ogre::Matrix4();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Matrix4__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Real arg8 ;
  Ogre::Real arg9 ;
  Ogre::Real arg10 ;
  Ogre::Real arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Real arg14 ;
  Ogre::Real arg15 ;
  Ogre::Real arg16 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  float val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  float val14 ;
  int ecode14 = 0 ;
  float val15 ;
  int ecode15 = 0 ;
  float val16 ;
  int ecode16 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Matrix4";
  Ogre::Matrix4 *result = 0 ;
  
  if ((argc < 16) || (argc > 16)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 16)",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","Ogre::Matrix4", 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","Ogre::Matrix4", 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","Ogre::Matrix4", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 7, argv[6] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_float(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 8, argv[7] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_float(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 9, argv[8] ));
  } 
  arg9 = static_cast< Ogre::Real >(val9);
  ecode10 = SWIG_AsVal_float(argv[9], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 10, argv[9] ));
  } 
  arg10 = static_cast< Ogre::Real >(val10);
  ecode11 = SWIG_AsVal_float(argv[10], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 11, argv[10] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  ecode12 = SWIG_AsVal_float(argv[11], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 12, argv[11] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[12], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 13, argv[12] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  ecode14 = SWIG_AsVal_float(argv[13], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 14, argv[13] ));
  } 
  arg14 = static_cast< Ogre::Real >(val14);
  ecode15 = SWIG_AsVal_float(argv[14], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 15, argv[14] ));
  } 
  arg15 = static_cast< Ogre::Real >(val15);
  ecode16 = SWIG_AsVal_float(argv[15], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4", 16, argv[15] ));
  } 
  arg16 = static_cast< Ogre::Real >(val16);
  result = (Ogre::Matrix4 *)new Ogre::Matrix4(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Matrix4__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Matrix4";
  Ogre::Matrix4 *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__Matrix3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","Ogre::Matrix4", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","Ogre::Matrix4", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = (Ogre::Matrix4 *)new Ogre::Matrix4((Ogre::Matrix3 const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Matrix4__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Matrix4";
  Ogre::Matrix4 *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__Quaternion,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::Matrix4", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::Matrix4", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = (Ogre::Matrix4 *)new Ogre::Matrix4((Ogre::Quaternion const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Matrix4(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[16];
  int ii;
  
  argc = nargs;
  if (argc > 16) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_Matrix4__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix4__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Matrix4__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 16) {
    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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_float(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_float(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_float(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_float(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_new_Matrix4__SWIG_1(nargs, args, self);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 16, "Matrix4.new", 
    "    Matrix4.new()\n"
    "    Matrix4.new(Ogre::Real m00, Ogre::Real m01, Ogre::Real m02, Ogre::Real m03, Ogre::Real m10, Ogre::Real m11, Ogre::Real m12, Ogre::Real m13, Ogre::Real m20, Ogre::Real m21, Ogre::Real m22, Ogre::Real m23, Ogre::Real m30, Ogre::Real m31, Ogre::Real m32, Ogre::Real m33)\n"
    "    Matrix4.new(Ogre::Matrix3 const &m3x3)\n"
    "    Matrix4.new(Ogre::Quaternion const &rot)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_concatenate(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","concatenate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","concatenate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","concatenate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->concatenate((Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4___mul____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4___mul____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Vector3 const &)*arg2);
  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_Matrix4___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4___mul____SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Plane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Plane 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","operator *", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","operator *", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->operator *((Ogre::Plane const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Plane(static_cast< const Ogre::Plane& >(result))), SWIGTYPE_p_Ogre__Plane, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.+

  call-seq:
    +(m2) -> Matrix4

Add operator.
*/
SWIGINTERN VALUE
_wrap_Matrix4___add__(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator +", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","operator +", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","operator +", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->operator +((Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.-

  call-seq:
    -(m2) -> Matrix4

Substraction operator.
*/
SWIGINTERN VALUE
_wrap_Matrix4___sub__(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator -", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","operator -", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","operator -", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->operator -((Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Matrix4.==

  call-seq:
    ==(m2) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Matrix4___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = (bool)((Ogre::Matrix4 const *)arg1)->operator ==((Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_transpose(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","transpose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = ((Ogre::Matrix4 const *)arg1)->transpose();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_setTrans(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","setTrans", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","setTrans", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setTrans", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setTrans((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_getTrans__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","getTrans", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = ((Ogre::Matrix4 const *)arg1)->getTrans();
  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_Matrix4_makeTrans__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","makeTrans", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","makeTrans", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","makeTrans", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->makeTrans((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_makeTrans__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 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 ;
  
  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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","makeTrans", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","makeTrans", 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","makeTrans", 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","makeTrans", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->makeTrans(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix4_makeTrans(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_Ogre__Matrix4, 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_Matrix4_makeTrans__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 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_Matrix4_makeTrans__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Matrix4.makeTrans", 
    "    void Matrix4.makeTrans(Ogre::Vector3 const &v)\n"
    "    void Matrix4.makeTrans(Ogre::Real tx, Ogre::Real ty, Ogre::Real tz)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_getTrans__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Matrix4 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 &","Ogre::Matrix4::getTrans", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Matrix4::getTrans", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = Ogre::Matrix4::getTrans((Ogre::Vector3 const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_getTrans__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 ;
  Ogre::Matrix4 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4::getTrans", 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","Ogre::Matrix4::getTrans", 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","Ogre::Matrix4::getTrans", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = Ogre::Matrix4::getTrans(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix4_getTrans(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Matrix4_getTrans__SWIG_0(nargs, args, self);
    }
  }
  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_Matrix4_getTrans__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_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_Matrix4_getTrans__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix4.getTrans", 
    "    Ogre::Matrix4 Matrix4.getTrans(Ogre::Matrix4 const *self)\n"
    "    Ogre::Matrix4 Matrix4.getTrans(Ogre::Vector3 const &v)\n"
    "    Ogre::Matrix4 Matrix4.getTrans(Ogre::Real t_x, Ogre::Real t_y, Ogre::Real t_z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_setScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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);
  (arg1)->setScale((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_getScale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::Matrix4 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 &","Ogre::Matrix4::getScale", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Matrix4::getScale", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = Ogre::Matrix4::getScale((Ogre::Vector3 const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_getScale__SWIG_1(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 ;
  Ogre::Matrix4 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Matrix4::getScale", 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","Ogre::Matrix4::getScale", 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","Ogre::Matrix4::getScale", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = Ogre::Matrix4::getScale(arg1,arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix4_getScale(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 == 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_Matrix4_getScale__SWIG_0(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_Matrix4_getScale__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix4.getScale", 
    "    Ogre::Matrix4 Matrix4.getScale(Ogre::Vector3 const &v)\n"
    "    Ogre::Matrix4 Matrix4.getScale(Ogre::Real s_x, Ogre::Real s_y, Ogre::Real s_z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_extract3x3Matrix(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix3 *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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","extract3x3Matrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 &","extract3x3Matrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 &","extract3x3Matrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  ((Ogre::Matrix4 const *)arg1)->extract3x3Matrix(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_hasScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","hasScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = (bool)((Ogre::Matrix4 const *)arg1)->hasScale();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_hasNegativeScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","hasNegativeScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = (bool)((Ogre::Matrix4 const *)arg1)->hasNegativeScale();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_extractQuaternion(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","extractQuaternion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = ((Ogre::Matrix4 const *)arg1)->extractQuaternion();
  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_Matrix4_ZERO_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Matrix4::ZERO), SWIGTYPE_p_Ogre__Matrix4,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Matrix4_ZEROAFFINE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Matrix4::ZEROAFFINE), SWIGTYPE_p_Ogre__Matrix4,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Matrix4_IDENTITY_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Matrix4::IDENTITY), SWIGTYPE_p_Ogre__Matrix4,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Matrix4_CLIPSPACE2DTOIMAGESPACE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::Matrix4::CLIPSPACE2DTOIMAGESPACE), SWIGTYPE_p_Ogre__Matrix4,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_Matrix4___mul____SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Matrix4 const *)arg1)->operator *(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix4___mul__(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_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix4___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 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_Matrix4___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix4___mul____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix4___mul____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Matrix4___mul____SWIG_4(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix4.__mul__", 
    "    Ogre::Matrix4 Matrix4.__mul__(Ogre::Matrix4 const &m2)\n"
    "    Ogre::Matrix4 Matrix4.__mul__(Ogre::Vector3 const &v)\n"
    "    Ogre::Matrix4 Matrix4.__mul__(Ogre::Vector4 const &v)\n"
    "    Ogre::Matrix4 Matrix4.__mul__(Ogre::Plane const &p)\n"
    "    Ogre::Matrix4 Matrix4.__mul__(Ogre::Real scalar)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_adjoint(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","adjoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = ((Ogre::Matrix4 const *)arg1)->adjoint();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_determinant(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","determinant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = (Ogre::Real)((Ogre::Matrix4 const *)arg1)->determinant();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_inverse(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","inverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = ((Ogre::Matrix4 const *)arg1)->inverse();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_makeTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","makeTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","makeTransform", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","makeTransform", 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 &","makeTransform", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","makeTransform", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","makeTransform", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","makeTransform", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  (arg1)->makeTransform((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_makeInverseTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","makeInverseTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","makeInverseTransform", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","makeInverseTransform", 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 &","makeInverseTransform", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","makeInverseTransform", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","makeInverseTransform", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","makeInverseTransform", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  (arg1)->makeInverseTransform((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_decomposition(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","decomposition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","decomposition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","decomposition", 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 &","decomposition", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","decomposition", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion &","decomposition", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion &","decomposition", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  ((Ogre::Matrix4 const *)arg1)->decomposition(*arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_isAffine(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","isAffine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = (bool)((Ogre::Matrix4 const *)arg1)->isAffine();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_inverseAffine(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","inverseAffine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = ((Ogre::Matrix4 const *)arg1)->inverseAffine();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_concatenateAffine(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","concatenateAffine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","concatenateAffine", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","concatenateAffine", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->concatenateAffine((Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Matrix4_transformAffine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","transformAffine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(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 &","transformAffine", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","transformAffine", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->transformAffine((Ogre::Vector3 const &)*arg2);
  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_Matrix4_transformAffine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = (Ogre::Matrix4 *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 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_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","transformAffine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","transformAffine", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","transformAffine", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = ((Ogre::Matrix4 const *)arg1)->transformAffine((Ogre::Vector4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Matrix4_transformAffine(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_Ogre__Matrix4, 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_Matrix4_transformAffine__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Matrix4_transformAffine__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Matrix4.transformAffine", 
    "    Ogre::Vector4 Matrix4.transformAffine(Ogre::Vector3 const &v)\n"
    "    Ogre::Vector4 Matrix4.transformAffine(Ogre::Vector4 const &v)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Matrix4(Ogre::Matrix4 *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap___mul____SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 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__Vector4,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","Ogre::operator *", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","Ogre::operator *", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","Ogre::operator *", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","Ogre::operator *", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = Ogre::operator *((Ogre::Vector4 const &)*arg1,(Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___mul__(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__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___mul____SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__mul__", 
    "    Ogre::Vector4 __mul__(Ogre::Real a, Ogre::Radian const &b)\n"
    "    Ogre::Vector4 __mul__(Ogre::Real a, Ogre::Degree const &b)\n"
    "    Ogre::Vector4 __mul__(Ogre::Vector4 const &v, Ogre::Matrix4 const &mat)\n");
  
  return Qnil;
}


swig_class SwigClassSimpleSpline;

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

SWIGINTERN VALUE
_wrap_new_SimpleSpline(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SimpleSpline";
  Ogre::SimpleSpline *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SimpleSpline *)new Ogre::SimpleSpline();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimpleSpline(Ogre::SimpleSpline *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SimpleSpline_addPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 0 ;
  Ogre::Vector3 *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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(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);
  (arg1)->addPoint((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleSpline_getPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline const *","getPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(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","getPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Vector3 *) &((Ogre::SimpleSpline const *)arg1)->getPoint(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleSpline_getNumPoints(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline const *","getNumPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(argp1);
  result = (unsigned short)((Ogre::SimpleSpline const *)arg1)->getNumPoints();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::SimpleSpline.clear

  call-seq:
    clear

Clear SimpleSpline contents.
*/
SWIGINTERN VALUE
_wrap_SimpleSpline_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleSpline_updatePoint(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 0 ;
  unsigned short arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline *","updatePoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(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","updatePoint", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(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 &","updatePoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","updatePoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->updatePoint(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleSpline_interpolate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline const *","interpolate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","interpolate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::SimpleSpline const *)arg1)->interpolate(arg2);
  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_SimpleSpline_interpolate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline const *","interpolate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(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","interpolate", 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","interpolate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = ((Ogre::SimpleSpline const *)arg1)->interpolate(arg2,arg3);
  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_SimpleSpline_interpolate(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_Ogre__SimpleSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SimpleSpline_interpolate__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SimpleSpline, 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_SimpleSpline_interpolate__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SimpleSpline.interpolate", 
    "    Ogre::Vector3 SimpleSpline.interpolate(Ogre::Real t)\n"
    "    Ogre::Vector3 SimpleSpline.interpolate(unsigned int fromIndex, Ogre::Real t)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleSpline_setAutoCalculate(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline *","setAutoCalculate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoCalculate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoCalculate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleSpline_recalcTangents(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleSpline *arg1 = (Ogre::SimpleSpline *) 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_Ogre__SimpleSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleSpline *","recalcTangents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleSpline * >(argp1);
  (arg1)->recalcTangents();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRotationalSpline;

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

SWIGINTERN VALUE
_wrap_new_RotationalSpline(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RotationalSpline";
  Ogre::RotationalSpline *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RotationalSpline *)new Ogre::RotationalSpline();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RotationalSpline(Ogre::RotationalSpline *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RotationalSpline_addPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  Ogre::Quaternion *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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","addPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(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 &","addPoint", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","addPoint", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->addPoint((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RotationalSpline_getPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Quaternion *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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline const *","getPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(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","getPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Quaternion *) &((Ogre::RotationalSpline const *)arg1)->getPoint(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RotationalSpline_getNumPoints(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline const *","getNumPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(argp1);
  result = (unsigned short)((Ogre::RotationalSpline const *)arg1)->getNumPoints();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RotationalSpline.clear

  call-seq:
    clear

Clear RotationalSpline contents.
*/
SWIGINTERN VALUE
_wrap_RotationalSpline_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RotationalSpline_updatePoint(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  unsigned short arg2 ;
  Ogre::Quaternion *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","updatePoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(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","updatePoint", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","updatePoint", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","updatePoint", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  (arg1)->updatePoint(arg2,(Ogre::Quaternion const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RotationalSpline_interpolate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  Ogre::Real arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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(self, &argp1,SWIGTYPE_p_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","interpolate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","interpolate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","interpolate", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->interpolate(arg2,arg3);
  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_RotationalSpline_interpolate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 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(self, &argp1,SWIGTYPE_p_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","interpolate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","interpolate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (arg1)->interpolate(arg2);
  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_RotationalSpline_interpolate__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  unsigned int arg2 ;
  Ogre::Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::Quaternion 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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","interpolate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(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","interpolate", 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","interpolate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","interpolate", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->interpolate(arg2,arg3,arg4);
  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_RotationalSpline_interpolate__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 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::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(self, &argp1,SWIGTYPE_p_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","interpolate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(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","interpolate", 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","interpolate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (arg1)->interpolate(arg2,arg3);
  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_RotationalSpline_interpolate(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_Ogre__RotationalSpline, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RotationalSpline_interpolate__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RotationalSpline, 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_RotationalSpline_interpolate__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RotationalSpline, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RotationalSpline_interpolate__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RotationalSpline, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RotationalSpline_interpolate__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RotationalSpline.interpolate", 
    "    Ogre::Quaternion RotationalSpline.interpolate(Ogre::Real t, bool useShortestPath)\n"
    "    Ogre::Quaternion RotationalSpline.interpolate(Ogre::Real t)\n"
    "    Ogre::Quaternion RotationalSpline.interpolate(unsigned int fromIndex, Ogre::Real t, bool useShortestPath)\n"
    "    Ogre::Quaternion RotationalSpline.interpolate(unsigned int fromIndex, Ogre::Real t)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RotationalSpline_setAutoCalculate(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","setAutoCalculate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoCalculate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoCalculate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RotationalSpline_recalcTangents(int argc, VALUE *argv, VALUE self) {
  Ogre::RotationalSpline *arg1 = (Ogre::RotationalSpline *) 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_Ogre__RotationalSpline, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RotationalSpline *","recalcTangents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RotationalSpline * >(argp1);
  (arg1)->recalcTangents();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassHardwareBuffer;

SWIGINTERN void
free_Ogre_HardwareBuffer(Ogre::HardwareBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwareBuffer_lock__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::LockOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","lock", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","lock", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::LockOptions >(val4);
  result = (void *)(arg1)->lock(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_lock__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  Ogre::HardwareBuffer::LockOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::LockOptions >(val2);
  result = (void *)(arg1)->lock(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBuffer_lock(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_Ogre__HardwareBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HardwareBuffer_lock__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 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_size_t(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_HardwareBuffer_lock__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "HardwareBuffer.lock", 
    "    void * HardwareBuffer.lock(size_t offset, size_t length, Ogre::HardwareBuffer::LockOptions options)\n"
    "    void * HardwareBuffer.lock(Ogre::HardwareBuffer::LockOptions options)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_unlock(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","unlock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  (arg1)->unlock();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_readData(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","readData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","readData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","readData", 4, argv[2] )); 
  }
  (arg1)->readData(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_writeData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","writeData", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_writeData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  (arg1)->writeData(arg2,arg3,(void const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBuffer_writeData(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HardwareBuffer_writeData__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_HardwareBuffer_writeData__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBuffer.writeData", 
    "    void HardwareBuffer.writeData(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void HardwareBuffer.writeData(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_copyData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  Ogre::HardwareBuffer *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","copyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer &","copyData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareBuffer &","copyData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareBuffer * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","copyData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","copyData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","copyData", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","copyData", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->copyData(*arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_copyData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  Ogre::HardwareBuffer *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","copyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer &","copyData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareBuffer &","copyData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareBuffer * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","copyData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","copyData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","copyData", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->copyData(*arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_copyData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  Ogre::HardwareBuffer *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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","copyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareBuffer,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer &","copyData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareBuffer &","copyData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareBuffer * >(argp2);
  (arg1)->copyData(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBuffer_copyData(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__HardwareBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwareBuffer_copyData__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_HardwareBuffer_copyData__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareBuffer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_HardwareBuffer_copyData__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "HardwareBuffer.copyData", 
    "    void HardwareBuffer.copyData(Ogre::HardwareBuffer &srcBuffer, size_t srcOffset, size_t dstOffset, size_t length, bool discardWholeBuffer)\n"
    "    void HardwareBuffer.copyData(Ogre::HardwareBuffer &srcBuffer, size_t srcOffset, size_t dstOffset, size_t length)\n"
    "    void HardwareBuffer.copyData(Ogre::HardwareBuffer &srcBuffer)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer__updateFromShadow(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","_updateFromShadow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  (arg1)->_updateFromShadow();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_getSizeInBytes(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer const *","getSizeInBytes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  result = ((Ogre::HardwareBuffer const *)arg1)->getSizeInBytes();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_getUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareBuffer::Usage 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer const *","getUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  result = (Ogre::HardwareBuffer::Usage)((Ogre::HardwareBuffer const *)arg1)->getUsage();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_isSystemMemory(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer const *","isSystemMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  result = (bool)((Ogre::HardwareBuffer const *)arg1)->isSystemMemory();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_hasShadowBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer const *","hasShadowBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  result = (bool)((Ogre::HardwareBuffer const *)arg1)->hasShadowBuffer();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_isLocked(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer const *","isLocked", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  result = (bool)((Ogre::HardwareBuffer const *)arg1)->isLocked();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBuffer_suppressHardwareUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBuffer *arg1 = (Ogre::HardwareBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","suppressHardwareUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","suppressHardwareUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->suppressHardwareUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassHardwareVertexBuffer;

SWIGINTERN void
free_Ogre_HardwareVertexBuffer(Ogre::HardwareVertexBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareBufferManagerBase *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_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  result = (Ogre::HardwareBufferManagerBase *)((Ogre::HardwareVertexBuffer const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_getVertexSize(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer const *","getVertexSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  result = ((Ogre::HardwareVertexBuffer const *)arg1)->getVertexSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_getNumVertices(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer const *","getNumVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  result = ((Ogre::HardwareVertexBuffer const *)arg1)->getNumVertices();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_getIsInstanceData(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer const *","getIsInstanceData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  result = (bool)((Ogre::HardwareVertexBuffer const *)arg1)->getIsInstanceData();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_setIsInstanceData(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer *","setIsInstanceData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setIsInstanceData", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setIsInstanceData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_getInstanceDataStepRate(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer const *","getInstanceDataStepRate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  result = ((Ogre::HardwareVertexBuffer const *)arg1)->getInstanceDataStepRate();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareVertexBuffer_setInstanceDataStepRate(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer *","setInstanceDataStepRate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInstanceDataStepRate", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setInstanceDataStepRate(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassHardwareVertexBufferSharedPtr;

SWIGINTERN VALUE
_wrap_new_HardwareVertexBufferSharedPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::HardwareVertexBufferSharedPtr";
  Ogre::HardwareVertexBufferSharedPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HardwareVertexBufferSharedPtr *)new Ogre::HardwareVertexBufferSharedPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_HardwareVertexBufferSharedPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBuffer *arg1 = (Ogre::HardwareVertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::HardwareVertexBufferSharedPtr";
  Ogre::HardwareVertexBufferSharedPtr *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__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer *","Ogre::HardwareVertexBufferSharedPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp1);
  result = (Ogre::HardwareVertexBufferSharedPtr *)new Ogre::HardwareVertexBufferSharedPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HardwareVertexBufferSharedPtr(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_HardwareVertexBufferSharedPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HardwareVertexBufferSharedPtr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HardwareVertexBufferSharedPtr.new", 
    "    HardwareVertexBufferSharedPtr.new()\n"
    "    HardwareVertexBufferSharedPtr.new(Ogre::HardwareVertexBuffer *buf)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_HardwareVertexBufferSharedPtr(Ogre::HardwareVertexBufferSharedPtr *arg1) {
    delete arg1;
}

swig_class SwigClassVertexElement;

SWIGINTERN VALUE
_wrap_new_VertexElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::VertexElement";
  Ogre::VertexElement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VertexElement *)new Ogre::VertexElement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_VertexElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  unsigned short arg1 ;
  size_t arg2 ;
  Ogre::VertexElementType arg3 ;
  Ogre::VertexElementSemantic arg4 ;
  unsigned short arg5 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexElement";
  Ogre::VertexElement *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned short","Ogre::VertexElement", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned short >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::VertexElement", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::VertexElementType","Ogre::VertexElement", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::VertexElementType >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","Ogre::VertexElement", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::VertexElementSemantic >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned short","Ogre::VertexElement", 5, argv[4] ));
  } 
  arg5 = static_cast< unsigned short >(val5);
  result = (Ogre::VertexElement *)new Ogre::VertexElement(arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VertexElement__SWIG_2(int argc, VALUE *argv, VALUE self) {
  unsigned short arg1 ;
  size_t arg2 ;
  Ogre::VertexElementType arg3 ;
  Ogre::VertexElementSemantic arg4 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexElement";
  Ogre::VertexElement *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned short","Ogre::VertexElement", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned short >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::VertexElement", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::VertexElementType","Ogre::VertexElement", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::VertexElementType >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","Ogre::VertexElement", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::VertexElementSemantic >(val4);
  result = (Ogre::VertexElement *)new Ogre::VertexElement(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_VertexElement(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_VertexElement__SWIG_0(nargs, args, self);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _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_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_VertexElement__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _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_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_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_VertexElement__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "VertexElement.new", 
    "    VertexElement.new()\n"
    "    VertexElement.new(unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    VertexElement.new(unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getSource(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","getSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  result = (unsigned short)((Ogre::VertexElement const *)arg1)->getSource();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","getOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  result = ((Ogre::VertexElement const *)arg1)->getOffset();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexElementType 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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  result = (Ogre::VertexElementType)((Ogre::VertexElement const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getSemantic(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexElementSemantic 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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","getSemantic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  result = (Ogre::VertexElementSemantic)((Ogre::VertexElement const *)arg1)->getSemantic();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  result = (unsigned short)((Ogre::VertexElement const *)arg1)->getIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  result = ((Ogre::VertexElement const *)arg1)->getSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getTypeSize(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElementType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::VertexElementType","Ogre::VertexElement::getTypeSize", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::VertexElementType >(val1);
  result = Ogre::VertexElement::getTypeSize(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getTypeCount(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElementType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned short result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::VertexElementType","Ogre::VertexElement::getTypeCount", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::VertexElementType >(val1);
  result = (unsigned short)Ogre::VertexElement::getTypeCount(arg1);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_multiplyTypeCount(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElementType arg1 ;
  unsigned short arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::VertexElementType 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( "", "Ogre::VertexElementType","Ogre::VertexElement::multiplyTypeCount", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::VertexElementType >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::VertexElement::multiplyTypeCount", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::VertexElementType)Ogre::VertexElement::multiplyTypeCount(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getBaseType(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElementType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Ogre::VertexElementType result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::VertexElementType","Ogre::VertexElement::getBaseType", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::VertexElementType >(val1);
  result = (Ogre::VertexElementType)Ogre::VertexElement::getBaseType(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_convertColourValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElementType arg1 ;
  Ogre::VertexElementType arg2 ;
  Ogre::uint32 *arg3 = (Ogre::uint32 *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  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( "", "Ogre::VertexElementType","Ogre::VertexElement::convertColourValue", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::VertexElementType >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementType","Ogre::VertexElement::convertColourValue", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::VertexElementType >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::uint32 *","Ogre::VertexElement::convertColourValue", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::uint32 * >(argp3);
  Ogre::VertexElement::convertColourValue(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_convertColourValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = 0 ;
  Ogre::VertexElementType arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::uint32 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__ColourValue,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","Ogre::VertexElement::convertColourValue", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","Ogre::VertexElement::convertColourValue", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementType","Ogre::VertexElement::convertColourValue", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::VertexElementType >(val2);
  result = (Ogre::uint32)Ogre::VertexElement::convertColourValue((Ogre::ColourValue const &)*arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexElement_convertColourValue(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VertexElement_convertColourValue__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexElement_convertColourValue__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "VertexElement.convertColourValue", 
    "    Ogre::uint32 VertexElement.convertColourValue(Ogre::VertexElementType srcType, Ogre::VertexElementType dstType, Ogre::uint32 *ptr)\n"
    "    Ogre::uint32 VertexElement.convertColourValue(Ogre::ColourValue const &src, Ogre::VertexElementType dst)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_getBestColourVertexElementType(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElementType result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VertexElementType)Ogre::VertexElement::getBestColourVertexElementType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexElement.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_VertexElement___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  Ogre::VertexElement *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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__VertexElement,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexElement const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexElement const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::VertexElement * >(argp2);
  result = (bool)((Ogre::VertexElement const *)arg1)->operator ==((Ogre::VertexElement const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_baseVertexPointerToElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *arg2 = (void *) 0 ;
  void **arg3 = (void **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","baseVertexPointerToElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","baseVertexPointerToElement", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_void, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void **","baseVertexPointerToElement", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< void ** >(argp3);
  ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_baseVertexPointerToElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *arg2 = (void *) 0 ;
  float **arg3 = (float **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","baseVertexPointerToElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","baseVertexPointerToElement", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float **","baseVertexPointerToElement", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float ** >(argp3);
  ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_baseVertexPointerToElement__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::RGBA **arg3 = (Ogre::RGBA **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","baseVertexPointerToElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","baseVertexPointerToElement", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RGBA **","baseVertexPointerToElement", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RGBA ** >(argp3);
  ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_baseVertexPointerToElement__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *arg2 = (void *) 0 ;
  unsigned char **arg3 = (unsigned char **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","baseVertexPointerToElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","baseVertexPointerToElement", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "unsigned char **","baseVertexPointerToElement", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< unsigned char ** >(argp3);
  ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexElement_baseVertexPointerToElement__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = (Ogre::VertexElement *) 0 ;
  void *arg2 = (void *) 0 ;
  unsigned short **arg3 = (unsigned short **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  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_Ogre__VertexElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const *","baseVertexPointerToElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","baseVertexPointerToElement", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "unsigned short **","baseVertexPointerToElement", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< unsigned short ** >(argp3);
  ((Ogre::VertexElement const *)arg1)->baseVertexPointerToElement(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexElement_baseVertexPointerToElement(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_void, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexElement_baseVertexPointerToElement__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexElement_baseVertexPointerToElement__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_unsigned_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexElement_baseVertexPointerToElement__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexElement_baseVertexPointerToElement__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexElement_baseVertexPointerToElement__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "VertexElement.baseVertexPointerToElement", 
    "    void VertexElement.baseVertexPointerToElement(void *pBase, void **pElem)\n"
    "    void VertexElement.baseVertexPointerToElement(void *pBase, float **pElem)\n"
    "    void VertexElement.baseVertexPointerToElement(void *pBase, Ogre::RGBA **pElem)\n"
    "    void VertexElement.baseVertexPointerToElement(void *pBase, unsigned char **pElem)\n"
    "    void VertexElement.baseVertexPointerToElement(void *pBase, unsigned short **pElem)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexElement(Ogre::VertexElement *arg1) {
    delete arg1;
}

swig_class SwigClassVertexDeclaration;

SWIGINTERN VALUE
_wrap_VertexDeclaration_vertexElementLess(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexElement *arg1 = 0 ;
  Ogre::VertexElement *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__VertexElement,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexElement const &","Ogre::VertexDeclaration::vertexElementLess", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexElement const &","Ogre::VertexDeclaration::vertexElementLess", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::VertexElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__VertexElement,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexElement const &","Ogre::VertexDeclaration::vertexElementLess", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexElement const &","Ogre::VertexDeclaration::vertexElementLess", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::VertexElement * >(argp2);
  result = (bool)Ogre::VertexDeclaration::vertexElementLess((Ogre::VertexElement const &)*arg1,(Ogre::VertexElement const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VertexDeclaration(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::VertexDeclaration";
  Ogre::VertexDeclaration *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VertexDeclaration *)new Ogre::VertexDeclaration();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexDeclaration(Ogre::VertexDeclaration *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_VertexDeclaration_getElementCount(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","getElementCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  result = ((Ogre::VertexDeclaration const *)arg1)->getElementCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_getElements(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexDeclaration::VertexElementList *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","getElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  result = (Ogre::VertexDeclaration::VertexElementList *) &((Ogre::VertexDeclaration const *)arg1)->getElements();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_getElement(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::VertexElement *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","getElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","getElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::VertexElement *)((Ogre::VertexDeclaration const *)arg1)->getElement(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_sort(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","sort", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  (arg1)->sort();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_closeGapsInSource(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","closeGapsInSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  (arg1)->closeGapsInSource();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_getAutoOrganisedDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","getAutoOrganisedDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getAutoOrganisedDeclaration", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","getAutoOrganisedDeclaration", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","getAutoOrganisedDeclaration", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::VertexDeclaration *)((Ogre::VertexDeclaration const *)arg1)->getAutoOrganisedDeclaration(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_getMaxSource(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","getMaxSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  result = (unsigned short)((Ogre::VertexDeclaration const *)arg1)->getMaxSource();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_addElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  size_t arg3 ;
  Ogre::VertexElementType arg4 ;
  Ogre::VertexElementSemantic arg5 ;
  unsigned short arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  Ogre::VertexElement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","addElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","addElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","addElement", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::VertexElementType","addElement", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::VertexElementType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","addElement", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::VertexElementSemantic >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "unsigned short","addElement", 6, argv[4] ));
  } 
  arg6 = static_cast< unsigned short >(val6);
  result = (Ogre::VertexElement *) &(arg1)->addElement(arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_addElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  size_t arg3 ;
  Ogre::VertexElementType arg4 ;
  Ogre::VertexElementSemantic arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::VertexElement *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","addElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","addElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","addElement", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::VertexElementType","addElement", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::VertexElementType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","addElement", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::VertexElementSemantic >(val5);
  result = (Ogre::VertexElement *) &(arg1)->addElement(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_addElement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_VertexDeclaration_addElement__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_VertexDeclaration_addElement__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "VertexDeclaration.addElement", 
    "    Ogre::VertexElement const & VertexDeclaration.addElement(unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    Ogre::VertexElement const & VertexDeclaration.addElement(unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_insertElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  size_t arg4 ;
  Ogre::VertexElementType arg5 ;
  Ogre::VertexElementSemantic arg6 ;
  unsigned short arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  Ogre::VertexElement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","insertElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","insertElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","insertElement", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","insertElement", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::VertexElementType","insertElement", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::VertexElementType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","insertElement", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::VertexElementSemantic >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "unsigned short","insertElement", 7, argv[5] ));
  } 
  arg7 = static_cast< unsigned short >(val7);
  result = (Ogre::VertexElement *) &(arg1)->insertElement(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_insertElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  size_t arg4 ;
  Ogre::VertexElementType arg5 ;
  Ogre::VertexElementSemantic arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Ogre::VertexElement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","insertElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","insertElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","insertElement", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","insertElement", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::VertexElementType","insertElement", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::VertexElementType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","insertElement", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::VertexElementSemantic >(val6);
  result = (Ogre::VertexElement *) &(arg1)->insertElement(arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_insertElement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(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_VertexDeclaration_insertElement__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(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) {
                {
                  int res = SWIG_AsVal_unsigned_SS_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_VertexDeclaration_insertElement__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "VertexDeclaration.insertElement", 
    "    Ogre::VertexElement const & VertexDeclaration.insertElement(unsigned short atPosition, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    Ogre::VertexElement const & VertexDeclaration.insertElement(unsigned short atPosition, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_removeElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","removeElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","removeElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removeElement(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_removeElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","removeElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","removeElement", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","removeElement", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  (arg1)->removeElement(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_removeElement__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","removeElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","removeElement", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  (arg1)->removeElement(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_removeElement(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_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VertexDeclaration_removeElement__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VertexDeclaration_removeElement__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VertexDeclaration_removeElement__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "VertexDeclaration.removeElement", 
    "    void VertexDeclaration.removeElement(unsigned short elem_index)\n"
    "    void VertexDeclaration.removeElement(Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    void VertexDeclaration.removeElement(Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_removeAllElements(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","removeAllElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  (arg1)->removeAllElements();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_modifyElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  size_t arg4 ;
  Ogre::VertexElementType arg5 ;
  Ogre::VertexElementSemantic arg6 ;
  unsigned short arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","modifyElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","modifyElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","modifyElement", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","modifyElement", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::VertexElementType","modifyElement", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::VertexElementType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","modifyElement", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::VertexElementSemantic >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "unsigned short","modifyElement", 7, argv[5] ));
  } 
  arg7 = static_cast< unsigned short >(val7);
  (arg1)->modifyElement(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_modifyElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  size_t arg4 ;
  Ogre::VertexElementType arg5 ;
  Ogre::VertexElementSemantic arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","modifyElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","modifyElement", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","modifyElement", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","modifyElement", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::VertexElementType","modifyElement", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::VertexElementType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","modifyElement", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::VertexElementSemantic >(val6);
  (arg1)->modifyElement(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_modifyElement(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(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_VertexDeclaration_modifyElement__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(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) {
                {
                  int res = SWIG_AsVal_unsigned_SS_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_VertexDeclaration_modifyElement__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "VertexDeclaration.modifyElement", 
    "    void VertexDeclaration.modifyElement(unsigned short elem_index, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic, unsigned short index)\n"
    "    void VertexDeclaration.modifyElement(unsigned short elem_index, unsigned short source, size_t offset, Ogre::VertexElementType theType, Ogre::VertexElementSemantic semantic)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_findElementBySemantic__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::VertexElement *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","findElementBySemantic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","findElementBySemantic", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","findElementBySemantic", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = (Ogre::VertexElement *)((Ogre::VertexDeclaration const *)arg1)->findElementBySemantic(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_findElementBySemantic__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::VertexElement *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","findElementBySemantic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","findElementBySemantic", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  result = (Ogre::VertexElement *)((Ogre::VertexDeclaration const *)arg1)->findElementBySemantic(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_findElementBySemantic(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_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VertexDeclaration_findElementBySemantic__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VertexDeclaration_findElementBySemantic__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "VertexDeclaration.findElementBySemantic", 
    "    Ogre::VertexElement const * VertexDeclaration.findElementBySemantic(Ogre::VertexElementSemantic sem, unsigned short index)\n"
    "    Ogre::VertexElement const * VertexDeclaration.findElementBySemantic(Ogre::VertexElementSemantic sem)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_findElementsBySource(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::list< Ogre::VertexElement,Ogre::STLAllocator< Ogre::VertexElement,Ogre::GeneralAllocPolicy > >::type > 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","findElementsBySource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","findElementsBySource", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = ((Ogre::VertexDeclaration const *)arg1)->findElementsBySource(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::VertexDeclaration::VertexElementList(static_cast< const Ogre::VertexDeclaration::VertexElementList& >(result))), SWIGTYPE_p_Ogre__listT_Ogre__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_getVertexSize(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","getVertexSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(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","getVertexSize", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = ((Ogre::VertexDeclaration const *)arg1)->getVertexSize(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_getNextFreeTextureCoordinate(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","getNextFreeTextureCoordinate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  result = (unsigned short)((Ogre::VertexDeclaration const *)arg1)->getNextFreeTextureCoordinate();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.clone

  call-seq:
    clone(mgr=0) -> VertexDeclaration
    clone -> VertexDeclaration

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_VertexDeclaration_clone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::HardwareBufferManagerBase *arg2 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp2);
  result = (Ogre::VertexDeclaration *)((Ogre::VertexDeclaration const *)arg1)->clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexDeclaration_clone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  result = (Ogre::VertexDeclaration *)((Ogre::VertexDeclaration const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexDeclaration_clone(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_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VertexDeclaration_clone__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_VertexDeclaration_clone__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "VertexDeclaration.clone", 
    "    Ogre::VertexDeclaration * VertexDeclaration.clone(Ogre::HardwareBufferManagerBase *mgr)\n"
    "    Ogre::VertexDeclaration * VertexDeclaration.clone()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::VertexDeclaration.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_VertexDeclaration___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::VertexDeclaration *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_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__VertexDeclaration,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexDeclaration const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  result = (bool)((Ogre::VertexDeclaration const *)arg1)->operator ==((Ogre::VertexDeclaration const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassVertexBufferBinding;

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

SWIGINTERN VALUE
_wrap_new_VertexBufferBinding(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::VertexBufferBinding";
  Ogre::VertexBufferBinding *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VertexBufferBinding *)new Ogre::VertexBufferBinding();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexBufferBinding(Ogre::VertexBufferBinding *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_VertexBufferBinding_setBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  unsigned short arg2 ;
  Ogre::HardwareVertexBufferSharedPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","setBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(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","setBinding", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","setBinding", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","setBinding", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp3);
  (arg1)->setBinding(arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_unsetBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","unsetBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(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","unsetBinding", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->unsetBinding(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_unsetAllBindings(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","unsetAllBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  (arg1)->unsetAllBindings();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_getBindings(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexBufferBinding::VertexBufferBindingMap *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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","getBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  result = (Ogre::VertexBufferBinding::VertexBufferBindingMap *) &((Ogre::VertexBufferBinding const *)arg1)->getBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_getBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","getBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(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","getBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::HardwareVertexBufferSharedPtr *) &((Ogre::VertexBufferBinding const *)arg1)->getBuffer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_isBufferBound(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","isBufferBound", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(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","isBufferBound", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (bool)((Ogre::VertexBufferBinding const *)arg1)->isBufferBound(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_getBufferCount(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","getBufferCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  result = ((Ogre::VertexBufferBinding const *)arg1)->getBufferCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_getNextIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","getNextIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  result = (unsigned short)((Ogre::VertexBufferBinding const *)arg1)->getNextIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_getLastBoundIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","getLastBoundIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  result = (unsigned short)((Ogre::VertexBufferBinding const *)arg1)->getLastBoundIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_hasGaps(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","hasGaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  result = (bool)((Ogre::VertexBufferBinding const *)arg1)->hasGaps();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_closeGaps(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 0 ;
  Ogre::VertexBufferBinding::BindingIndexMap *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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","closeGaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__mapT_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding::BindingIndexMap &","closeGaps", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexBufferBinding::BindingIndexMap &","closeGaps", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBufferBinding::BindingIndexMap * >(argp2);
  (arg1)->closeGaps(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexBufferBinding_getHasInstanceData(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexBufferBinding *arg1 = (Ogre::VertexBufferBinding *) 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_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding const *","getHasInstanceData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp1);
  result = (bool)((Ogre::VertexBufferBinding const *)arg1)->getHasInstanceData();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassKeyFrame;

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

SWIGINTERN VALUE
_wrap_new_KeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::KeyFrame";
  Ogre::KeyFrame *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__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","Ogre::KeyFrame", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::KeyFrame", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::KeyFrame *)new Ogre::KeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_KeyFrame(Ogre::KeyFrame *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_KeyFrame_getTime(int argc, VALUE *argv, VALUE self) {
  Ogre::KeyFrame *arg1 = (Ogre::KeyFrame *) 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_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::KeyFrame const *","getTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::KeyFrame * >(argp1);
  result = (Ogre::Real)((Ogre::KeyFrame const *)arg1)->getTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_KeyFrame__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::KeyFrame *arg1 = (Ogre::KeyFrame *) 0 ;
  Ogre::AnimationTrack *arg2 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::KeyFrame *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_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::KeyFrame const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::KeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationTrack * >(argp2);
  result = (Ogre::KeyFrame *)((Ogre::KeyFrame const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassNumericKeyFrame;

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

SWIGINTERN VALUE
_wrap_new_NumericKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::NumericKeyFrame";
  Ogre::NumericKeyFrame *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__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","Ogre::NumericKeyFrame", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::NumericKeyFrame", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::NumericKeyFrame *)new Ogre::NumericKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NumericKeyFrame(Ogre::NumericKeyFrame *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_NumericKeyFrame_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericKeyFrame *arg1 = (Ogre::NumericKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnyNumeric *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_Ogre__NumericKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericKeyFrame const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericKeyFrame * >(argp1);
  result = (Ogre::AnyNumeric *) &((Ogre::NumericKeyFrame const *)arg1)->getValue();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnyNumeric, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericKeyFrame_setValue(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericKeyFrame *arg1 = (Ogre::NumericKeyFrame *) 0 ;
  Ogre::AnyNumeric *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_Ogre__NumericKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericKeyFrame *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericKeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnyNumeric,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnyNumeric const &","setValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnyNumeric const &","setValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnyNumeric * >(argp2);
  (arg1)->setValue((Ogre::AnyNumeric const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericKeyFrame__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericKeyFrame *arg1 = (Ogre::NumericKeyFrame *) 0 ;
  Ogre::AnimationTrack *arg2 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::KeyFrame *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_Ogre__NumericKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericKeyFrame const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericKeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationTrack * >(argp2);
  result = (Ogre::KeyFrame *)((Ogre::NumericKeyFrame const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassTransformKeyFrame;

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

SWIGINTERN VALUE
_wrap_new_TransformKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TransformKeyFrame";
  Ogre::TransformKeyFrame *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__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","Ogre::TransformKeyFrame", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::TransformKeyFrame", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::TransformKeyFrame *)new Ogre::TransformKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TransformKeyFrame(Ogre::TransformKeyFrame *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TransformKeyFrame_setTranslate(int argc, VALUE *argv, VALUE self) {
  Ogre::TransformKeyFrame *arg1 = (Ogre::TransformKeyFrame *) 0 ;
  Ogre::Vector3 *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_Ogre__TransformKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TransformKeyFrame *","setTranslate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TransformKeyFrame * >(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 &","setTranslate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setTranslate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setTranslate((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TransformKeyFrame_getTranslate(int argc, VALUE *argv, VALUE self) {
  Ogre::TransformKeyFrame *arg1 = (Ogre::TransformKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TransformKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TransformKeyFrame const *","getTranslate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TransformKeyFrame * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::TransformKeyFrame const *)arg1)->getTranslate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TransformKeyFrame_setScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TransformKeyFrame *arg1 = (Ogre::TransformKeyFrame *) 0 ;
  Ogre::Vector3 *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_Ogre__TransformKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TransformKeyFrame *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TransformKeyFrame * >(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);
  (arg1)->setScale((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TransformKeyFrame_getScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TransformKeyFrame *arg1 = (Ogre::TransformKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TransformKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TransformKeyFrame const *","getScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TransformKeyFrame * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::TransformKeyFrame const *)arg1)->getScale();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TransformKeyFrame_setRotation(int argc, VALUE *argv, VALUE self) {
  Ogre::TransformKeyFrame *arg1 = (Ogre::TransformKeyFrame *) 0 ;
  Ogre::Quaternion *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_Ogre__TransformKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TransformKeyFrame *","setRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TransformKeyFrame * >(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 &","setRotation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setRotation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->setRotation((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TransformKeyFrame_getRotation(int argc, VALUE *argv, VALUE self) {
  Ogre::TransformKeyFrame *arg1 = (Ogre::TransformKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__TransformKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TransformKeyFrame const *","getRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TransformKeyFrame * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::TransformKeyFrame const *)arg1)->getRotation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TransformKeyFrame__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::TransformKeyFrame *arg1 = (Ogre::TransformKeyFrame *) 0 ;
  Ogre::AnimationTrack *arg2 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::KeyFrame *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_Ogre__TransformKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TransformKeyFrame const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TransformKeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationTrack * >(argp2);
  result = (Ogre::KeyFrame *)((Ogre::TransformKeyFrame const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassVertexMorphKeyFrame;

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

SWIGINTERN VALUE
_wrap_new_VertexMorphKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexMorphKeyFrame";
  Ogre::VertexMorphKeyFrame *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__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","Ogre::VertexMorphKeyFrame", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::VertexMorphKeyFrame", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::VertexMorphKeyFrame *)new Ogre::VertexMorphKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexMorphKeyFrame(Ogre::VertexMorphKeyFrame *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_VertexMorphKeyFrame_setVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexMorphKeyFrame *arg1 = (Ogre::VertexMorphKeyFrame *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__VertexMorphKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexMorphKeyFrame *","setVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexMorphKeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","setVertexBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","setVertexBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  (arg1)->setVertexBuffer((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexMorphKeyFrame_getVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexMorphKeyFrame *arg1 = (Ogre::VertexMorphKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__VertexMorphKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexMorphKeyFrame const *","getVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexMorphKeyFrame * >(argp1);
  result = (Ogre::HardwareVertexBufferSharedPtr *) &((Ogre::VertexMorphKeyFrame const *)arg1)->getVertexBuffer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexMorphKeyFrame__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexMorphKeyFrame *arg1 = (Ogre::VertexMorphKeyFrame *) 0 ;
  Ogre::AnimationTrack *arg2 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::KeyFrame *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_Ogre__VertexMorphKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexMorphKeyFrame const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexMorphKeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationTrack * >(argp2);
  result = (Ogre::KeyFrame *)((Ogre::VertexMorphKeyFrame const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassVertexPoseKeyFrame;

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

SWIGINTERN VALUE
_wrap_new_VertexPoseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexPoseKeyFrame";
  Ogre::VertexPoseKeyFrame *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__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","Ogre::VertexPoseKeyFrame", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::VertexPoseKeyFrame", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::VertexPoseKeyFrame *)new Ogre::VertexPoseKeyFrame((Ogre::AnimationTrack const *)arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexPoseKeyFrame(Ogre::VertexPoseKeyFrame *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_addPoseReference(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame *","addPoseReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","addPoseReference", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addPoseReference", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->addPoseReference(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_updatePoseReference(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame *","updatePoseReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","updatePoseReference", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","updatePoseReference", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->updatePoseReference(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_removePoseReference(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame *","removePoseReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","removePoseReference", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->removePoseReference(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_removeAllPoseReferences(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame *","removeAllPoseReferences", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  (arg1)->removeAllPoseReferences();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_getPoseReferences(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexPoseKeyFrame::PoseRefList *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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame const *","getPoseReferences", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  result = (Ogre::VertexPoseKeyFrame::PoseRefList *) &((Ogre::VertexPoseKeyFrame const *)arg1)->getPoseReferences();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_getPoseReferenceIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< PoseRef,Ogre::STLAllocator< PoseRef,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame *","getPoseReferenceIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  result = (arg1)->getPoseReferenceIterator();
  vresult = SWIG_NewPointerObj((new Ogre::VertexPoseKeyFrame::PoseRefIterator(static_cast< const Ogre::VertexPoseKeyFrame::PoseRefIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame_getPoseReferenceIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< PoseRef,Ogre::STLAllocator< PoseRef,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame const *","getPoseReferenceIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  result = ((Ogre::VertexPoseKeyFrame const *)arg1)->getPoseReferenceIterator();
  vresult = SWIG_NewPointerObj((new Ogre::VertexPoseKeyFrame::ConstPoseRefIterator(static_cast< const Ogre::VertexPoseKeyFrame::ConstPoseRefIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexPoseKeyFrame_getPoseReferenceIterator(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_Ogre__VertexPoseKeyFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VertexPoseKeyFrame_getPoseReferenceIterator__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexPoseKeyFrame, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VertexPoseKeyFrame_getPoseReferenceIterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "VertexPoseKeyFrame.getPoseReferenceIterator", 
    "    Ogre::VertexPoseKeyFrame::ConstPoseRefIterator VertexPoseKeyFrame.getPoseReferenceIterator()\n"
    "    Ogre::VertexPoseKeyFrame::ConstPoseRefIterator VertexPoseKeyFrame.getPoseReferenceIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  Ogre::AnimationTrack *arg2 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::KeyFrame *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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationTrack * >(argp2);
  result = (Ogre::KeyFrame *)((Ogre::VertexPoseKeyFrame const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexPoseKeyFrame__applyBaseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexPoseKeyFrame *arg1 = (Ogre::VertexPoseKeyFrame *) 0 ;
  Ogre::VertexPoseKeyFrame *arg2 = (Ogre::VertexPoseKeyFrame *) 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_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame *","_applyBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexPoseKeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexPoseKeyFrame const *","_applyBaseKeyFrame", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexPoseKeyFrame * >(argp2);
  (arg1)->_applyBaseKeyFrame((Ogre::VertexPoseKeyFrame const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPose;

SWIGINTERN VALUE
_wrap_new_Pose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ushort arg1 ;
  Ogre::String *arg2 = 0 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Pose";
  Ogre::Pose *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::ushort","Ogre::Pose", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::ushort >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Pose", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Pose", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Pose *)new Ogre::Pose(arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Pose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ushort arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Pose";
  Ogre::Pose *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::ushort","Ogre::Pose", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::ushort >(val1);
  result = (Ogre::Pose *)new Ogre::Pose(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Pose(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;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Pose__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _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_new_Pose__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pose.new", 
    "    Pose.new(Ogre::ushort target, Ogre::String const &name)\n"
    "    Pose.new(Ogre::ushort target)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Pose(Ogre::Pose *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Pose_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (Ogre::String *) &((Ogre::Pose const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","getTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (Ogre::ushort)((Ogre::Pose const *)arg1)->getTarget();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getIncludesNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","getIncludesNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (bool)((Ogre::Pose const *)arg1)->getIncludesNormals();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_addVertex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 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 ;
  
  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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose *","addVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","addVertex", 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 &","addVertex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addVertex", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->addVertex(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_addVertex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  size_t arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose *","addVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","addVertex", 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 &","addVertex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addVertex", 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 &","addVertex", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addVertex", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->addVertex(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pose_addVertex(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_Ogre__Pose, 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_Pose_addVertex__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pose, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Pose_addVertex__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pose.addVertex", 
    "    void Pose.addVertex(size_t index, Ogre::Vector3 const &offset)\n"
    "    void Pose.addVertex(size_t index, Ogre::Vector3 const &offset, Ogre::Vector3 const &normal)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_removeVertex(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose *","removeVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removeVertex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removeVertex(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_clearVertices(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose *","clearVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  (arg1)->clearVertices();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getVertexOffsetIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","getVertexOffsetIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = ((Ogre::Pose const *)arg1)->getVertexOffsetIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Pose::ConstVertexOffsetIterator(static_cast< const Ogre::Pose::ConstVertexOffsetIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getVertexOffsetIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose *","getVertexOffsetIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (arg1)->getVertexOffsetIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Pose::VertexOffsetIterator(static_cast< const Ogre::Pose::VertexOffsetIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pose_getVertexOffsetIterator(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_Ogre__Pose, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pose_getVertexOffsetIterator__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pose, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pose_getVertexOffsetIterator__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pose.getVertexOffsetIterator", 
    "    Ogre::Pose::VertexOffsetIterator Pose.getVertexOffsetIterator()\n"
    "    Ogre::Pose::VertexOffsetIterator Pose.getVertexOffsetIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getVertexOffsets(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pose::VertexOffsetMap *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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","getVertexOffsets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (Ogre::Pose::VertexOffsetMap *) &((Ogre::Pose const *)arg1)->getVertexOffsets();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getNormalsIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","getNormalsIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = ((Ogre::Pose const *)arg1)->getNormalsIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Pose::ConstNormalsIterator(static_cast< const Ogre::Pose::ConstNormalsIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getNormalsIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose *","getNormalsIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (arg1)->getNormalsIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Pose::NormalsIterator(static_cast< const Ogre::Pose::NormalsIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pose_getNormalsIterator(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_Ogre__Pose, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pose_getNormalsIterator__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pose, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pose_getNormalsIterator__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pose.getNormalsIterator", 
    "    Ogre::Pose::NormalsIterator Pose.getNormalsIterator()\n"
    "    Ogre::Pose::NormalsIterator Pose.getNormalsIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose_getNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pose::NormalsMap *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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","getNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (Ogre::Pose::NormalsMap *) &((Ogre::Pose const *)arg1)->getNormals();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pose__getHardwareVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","_getHardwareVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData const *","_getHardwareVertexBuffer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  result = (Ogre::HardwareVertexBufferSharedPtr *) &((Ogre::Pose const *)arg1)->_getHardwareVertexBuffer((Ogre::VertexData const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Pose.clone

  call-seq:
    clone -> Pose

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_Pose_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::Pose *arg1 = (Ogre::Pose *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pose *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_Ogre__Pose, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pose const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pose * >(argp1);
  result = (Ogre::Pose *)((Ogre::Pose const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassTimeIndex;

SWIGINTERN VALUE
_wrap_new_TimeIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TimeIndex";
  Ogre::TimeIndex *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","Ogre::TimeIndex", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::TimeIndex *)new Ogre::TimeIndex(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TimeIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::uint arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TimeIndex";
  Ogre::TimeIndex *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","Ogre::TimeIndex", 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( "", "Ogre::uint","Ogre::TimeIndex", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint >(val2);
  result = (Ogre::TimeIndex *)new Ogre::TimeIndex(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TimeIndex(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;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_TimeIndex__SWIG_0(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_TimeIndex__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TimeIndex.new", 
    "    TimeIndex.new(Ogre::Real timePos)\n"
    "    TimeIndex.new(Ogre::Real timePos, Ogre::uint keyIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TimeIndex_hasKeyIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::TimeIndex *arg1 = (Ogre::TimeIndex *) 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_Ogre__TimeIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TimeIndex const *","hasKeyIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TimeIndex * >(argp1);
  result = (bool)((Ogre::TimeIndex const *)arg1)->hasKeyIndex();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TimeIndex_getTimePos(int argc, VALUE *argv, VALUE self) {
  Ogre::TimeIndex *arg1 = (Ogre::TimeIndex *) 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_Ogre__TimeIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TimeIndex const *","getTimePos", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TimeIndex * >(argp1);
  result = (Ogre::Real)((Ogre::TimeIndex const *)arg1)->getTimePos();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TimeIndex_getKeyIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::TimeIndex *arg1 = (Ogre::TimeIndex *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint 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_Ogre__TimeIndex, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TimeIndex const *","getKeyIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TimeIndex * >(argp1);
  result = (Ogre::uint)((Ogre::TimeIndex const *)arg1)->getKeyIndex();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TimeIndex(Ogre::TimeIndex *arg1) {
    delete arg1;
}

swig_class SwigClassAnimationTrack;

SWIGINTERN void
free_Ogre_AnimationTrack(Ogre::AnimationTrack *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AnimationTrack_getHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","getHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  result = (unsigned short)((Ogre::AnimationTrack const *)arg1)->getHandle();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_getNumKeyFrames(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","getNumKeyFrames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  result = (unsigned short)((Ogre::AnimationTrack const *)arg1)->getNumKeyFrames();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_getKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::KeyFrame *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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","getKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(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","getKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::KeyFrame *)((Ogre::AnimationTrack const *)arg1)->getKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_getKeyFramesAtTime__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::KeyFrame **arg3 = (Ogre::KeyFrame **) 0 ;
  Ogre::KeyFrame **arg4 = (Ogre::KeyFrame **) 0 ;
  unsigned short *arg5 = (unsigned short *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Ogre::Real result;
  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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","getKeyFramesAtTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","getKeyFramesAtTime", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","getKeyFramesAtTime", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::KeyFrame **","getKeyFramesAtTime", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::KeyFrame ** >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::KeyFrame **","getKeyFramesAtTime", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::KeyFrame ** >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "unsigned short *","getKeyFramesAtTime", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< unsigned short * >(argp5);
  result = (Ogre::Real)((Ogre::AnimationTrack const *)arg1)->getKeyFramesAtTime((Ogre::TimeIndex const &)*arg2,arg3,arg4,arg5);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_getKeyFramesAtTime__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::KeyFrame **arg3 = (Ogre::KeyFrame **) 0 ;
  Ogre::KeyFrame **arg4 = (Ogre::KeyFrame **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","getKeyFramesAtTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","getKeyFramesAtTime", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","getKeyFramesAtTime", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::KeyFrame **","getKeyFramesAtTime", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::KeyFrame ** >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::KeyFrame **","getKeyFramesAtTime", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::KeyFrame ** >(argp4);
  result = (Ogre::Real)((Ogre::AnimationTrack const *)arg1)->getKeyFramesAtTime((Ogre::TimeIndex const &)*arg2,arg3,arg4);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationTrack_getKeyFramesAtTime(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_Ogre__KeyFrame, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_p_Ogre__KeyFrame, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_AnimationTrack_getKeyFramesAtTime__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_Ogre__KeyFrame, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_p_Ogre__KeyFrame, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_unsigned_short, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_AnimationTrack_getKeyFramesAtTime__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "AnimationTrack.getKeyFramesAtTime", 
    "    Ogre::Real AnimationTrack.getKeyFramesAtTime(Ogre::TimeIndex const &timeIndex, Ogre::KeyFrame **keyFrame1, Ogre::KeyFrame **keyFrame2, unsigned short *firstKeyIndex)\n"
    "    Ogre::Real AnimationTrack.getKeyFramesAtTime(Ogre::TimeIndex const &timeIndex, Ogre::KeyFrame **keyFrame1, Ogre::KeyFrame **keyFrame2)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_createKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::KeyFrame *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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","createKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::KeyFrame *)(arg1)->createKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_removeKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","removeKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(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","removeKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removeKeyFrame(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_removeAllKeyFrames(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","removeAllKeyFrames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  (arg1)->removeAllKeyFrames();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_getInterpolatedKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::KeyFrame *arg3 = (Ogre::KeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","getInterpolatedKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::KeyFrame *","getInterpolatedKeyFrame", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::KeyFrame * >(argp3);
  ((Ogre::AnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_apply__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_apply__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_apply__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::TimeIndex *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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationTrack_apply(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_Ogre__AnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AnimationTrack_apply__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_AnimationTrack_apply__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 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) {
            return _wrap_AnimationTrack_apply__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "AnimationTrack.apply", 
    "    void AnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void AnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void AnimationTrack.apply(Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack__keyFrameDataChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","_keyFrameDataChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  ((Ogre::AnimationTrack const *)arg1)->_keyFrameDataChanged();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_hasNonZeroKeyFrames(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","hasNonZeroKeyFrames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  result = (bool)((Ogre::AnimationTrack const *)arg1)->hasNonZeroKeyFrames();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_optimise(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","optimise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  (arg1)->optimise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack__collectKeyFrameTimes(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type *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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_collectKeyFrameTimes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type &","_collectKeyFrameTimes", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type &","_collectKeyFrameTimes", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  (arg1)->_collectKeyFrameTimes(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack__buildKeyFrameIndexMap(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type *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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_buildKeyFrameIndexMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type const &","_buildKeyFrameIndexMap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type const &","_buildKeyFrameIndexMap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  (arg1)->_buildKeyFrameIndexMap((Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack__applyBaseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::KeyFrame *arg2 = (Ogre::KeyFrame *) 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","_applyBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::KeyFrame const *","_applyBaseKeyFrame", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::KeyFrame * >(argp2);
  (arg1)->_applyBaseKeyFrame((Ogre::KeyFrame const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_setListener(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  Ogre::AnimationTrack::Listener *arg2 = (Ogre::AnimationTrack::Listener *) 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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack *","setListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationTrack__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationTrack::Listener *","setListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationTrack::Listener * >(argp2);
  (arg1)->setListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationTrack_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationTrack *arg1 = (Ogre::AnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Animation *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_Ogre__AnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationTrack const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationTrack * >(argp1);
  result = (Ogre::Animation *)((Ogre::AnimationTrack const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassNumericAnimationTrack;

SWIGINTERN VALUE
_wrap_new_NumericAnimationTrack__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::NumericAnimationTrack";
  Ogre::NumericAnimationTrack *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__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","Ogre::NumericAnimationTrack", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::NumericAnimationTrack", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::NumericAnimationTrack *)new Ogre::NumericAnimationTrack(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_NumericAnimationTrack__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::AnimableValuePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::NumericAnimationTrack";
  Ogre::NumericAnimationTrack *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","Ogre::NumericAnimationTrack", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::NumericAnimationTrack", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr &","Ogre::NumericAnimationTrack", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr &","Ogre::NumericAnimationTrack", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp3);
  result = (Ogre::NumericAnimationTrack *)new Ogre::NumericAnimationTrack(arg1,arg2,*arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NumericAnimationTrack(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_NumericAnimationTrack__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NumericAnimationTrack__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "NumericAnimationTrack.new", 
    "    NumericAnimationTrack.new(Ogre::Animation *parent, unsigned short handle)\n"
    "    NumericAnimationTrack.new(Ogre::Animation *parent, unsigned short handle, Ogre::AnimableValuePtr &target)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_createNumericKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::NumericKeyFrame *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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","createNumericKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createNumericKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::NumericKeyFrame *)(arg1)->createNumericKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_getInterpolatedKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::KeyFrame *arg3 = (Ogre::KeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack const *","getInterpolatedKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::KeyFrame *","getInterpolatedKeyFrame", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::KeyFrame * >(argp3);
  ((Ogre::NumericAnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_apply__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_apply__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_apply__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::TimeIndex *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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NumericAnimationTrack_apply(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_Ogre__NumericAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_NumericAnimationTrack_apply__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NumericAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_NumericAnimationTrack_apply__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NumericAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 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) {
            return _wrap_NumericAnimationTrack_apply__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "NumericAnimationTrack.apply", 
    "    void NumericAnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void NumericAnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void NumericAnimationTrack.apply(Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_applyToAnimable__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::AnimableValuePtr *arg2 = 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","applyToAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToAnimable", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToAnimable", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","applyToAnimable", 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","applyToAnimable", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,(Ogre::TimeIndex const &)*arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_applyToAnimable__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::AnimableValuePtr *arg2 = 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","applyToAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToAnimable", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToAnimable", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","applyToAnimable", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,(Ogre::TimeIndex const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_applyToAnimable__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::AnimableValuePtr *arg2 = 0 ;
  Ogre::TimeIndex *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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","applyToAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToAnimable", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToAnimable", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,(Ogre::TimeIndex const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NumericAnimationTrack_applyToAnimable(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_Ogre__NumericAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_NumericAnimationTrack_applyToAnimable__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NumericAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_NumericAnimationTrack_applyToAnimable__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NumericAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _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_NumericAnimationTrack_applyToAnimable__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "NumericAnimationTrack.applyToAnimable", 
    "    void NumericAnimationTrack.applyToAnimable(Ogre::AnimableValuePtr const &anim, Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void NumericAnimationTrack.applyToAnimable(Ogre::AnimableValuePtr const &anim, Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void NumericAnimationTrack.applyToAnimable(Ogre::AnimableValuePtr const &anim, Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_getAssociatedAnimable(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimableValuePtr *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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack const *","getAssociatedAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  result = (Ogre::AnimableValuePtr *) &((Ogre::NumericAnimationTrack const *)arg1)->getAssociatedAnimable();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_setAssociatedAnimable(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::AnimableValuePtr *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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack *","setAssociatedAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","setAssociatedAnimable", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","setAssociatedAnimable", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp2);
  (arg1)->setAssociatedAnimable((Ogre::AnimableValuePtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack_getNumericKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::NumericKeyFrame *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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack const *","getNumericKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(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","getNumericKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::NumericKeyFrame *)((Ogre::NumericAnimationTrack const *)arg1)->getNumericKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NumericAnimationTrack__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::NumericAnimationTrack *arg1 = (Ogre::NumericAnimationTrack *) 0 ;
  Ogre::Animation *arg2 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::NumericAnimationTrack *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_Ogre__NumericAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NumericAnimationTrack const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NumericAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Animation *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Animation * >(argp2);
  result = (Ogre::NumericAnimationTrack *)((Ogre::NumericAnimationTrack const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NumericAnimationTrack(Ogre::NumericAnimationTrack *arg1) {
    delete arg1;
}

swig_class SwigClassNodeAnimationTrack;

SWIGINTERN VALUE
_wrap_new_NodeAnimationTrack__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::NodeAnimationTrack";
  Ogre::NodeAnimationTrack *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__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","Ogre::NodeAnimationTrack", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::NodeAnimationTrack", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::NodeAnimationTrack *)new Ogre::NodeAnimationTrack(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_NodeAnimationTrack__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::Node *arg3 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::NodeAnimationTrack";
  Ogre::NodeAnimationTrack *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","Ogre::NodeAnimationTrack", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::NodeAnimationTrack", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Node *","Ogre::NodeAnimationTrack", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::Node * >(argp3);
  result = (Ogre::NodeAnimationTrack *)new Ogre::NodeAnimationTrack(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NodeAnimationTrack(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_NodeAnimationTrack__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Node, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_NodeAnimationTrack__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "NodeAnimationTrack.new", 
    "    NodeAnimationTrack.new(Ogre::Animation *parent, unsigned short handle)\n"
    "    NodeAnimationTrack.new(Ogre::Animation *parent, unsigned short handle, Ogre::Node *targetNode)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_NodeAnimationTrack(Ogre::NodeAnimationTrack *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_NodeAnimationTrack_createNodeKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::TransformKeyFrame *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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","createNodeKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createNodeKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::TransformKeyFrame *)(arg1)->createNodeKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TransformKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_getAssociatedNode(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Node *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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack const *","getAssociatedNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  result = (Ogre::Node *)((Ogre::NodeAnimationTrack const *)arg1)->getAssociatedNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_setAssociatedNode(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","setAssociatedNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","setAssociatedNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->setAssociatedNode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_applyToNode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","applyToNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","applyToNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToNode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToNode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","applyToNode", 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","applyToNode", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->applyToNode(arg2,(Ogre::TimeIndex const &)*arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_applyToNode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","applyToNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","applyToNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToNode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToNode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","applyToNode", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->applyToNode(arg2,(Ogre::TimeIndex const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_applyToNode__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","applyToNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","applyToNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToNode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToNode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  (arg1)->applyToNode(arg2,(Ogre::TimeIndex const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NodeAnimationTrack_applyToNode(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_Ogre__NodeAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_NodeAnimationTrack_applyToNode__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NodeAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_NodeAnimationTrack_applyToNode__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NodeAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _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_NodeAnimationTrack_applyToNode__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "NodeAnimationTrack.applyToNode", 
    "    void NodeAnimationTrack.applyToNode(Ogre::Node *node, Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void NodeAnimationTrack.applyToNode(Ogre::Node *node, Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void NodeAnimationTrack.applyToNode(Ogre::Node *node, Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_setUseShortestRotationPath(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","setUseShortestRotationPath", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseShortestRotationPath", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseShortestRotationPath(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_getUseShortestRotationPath(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack const *","getUseShortestRotationPath", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  result = (bool)((Ogre::NodeAnimationTrack const *)arg1)->getUseShortestRotationPath();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_getInterpolatedKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::KeyFrame *arg3 = (Ogre::KeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack const *","getInterpolatedKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::KeyFrame *","getInterpolatedKeyFrame", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::KeyFrame * >(argp3);
  ((Ogre::NodeAnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_apply__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_apply__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_apply__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::TimeIndex *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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NodeAnimationTrack_apply(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_Ogre__NodeAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_NodeAnimationTrack_apply__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NodeAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_NodeAnimationTrack_apply__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NodeAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 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) {
            return _wrap_NodeAnimationTrack_apply__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "NodeAnimationTrack.apply", 
    "    void NodeAnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void NodeAnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void NodeAnimationTrack.apply(Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack__keyFrameDataChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack const *","_keyFrameDataChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  ((Ogre::NodeAnimationTrack const *)arg1)->_keyFrameDataChanged();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_getNodeKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::TransformKeyFrame *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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack const *","getNodeKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(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","getNodeKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::TransformKeyFrame *)((Ogre::NodeAnimationTrack const *)arg1)->getNodeKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TransformKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_hasNonZeroKeyFrames(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack const *","hasNonZeroKeyFrames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  result = (bool)((Ogre::NodeAnimationTrack const *)arg1)->hasNonZeroKeyFrames();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack_optimise(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","optimise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  (arg1)->optimise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::Animation *arg2 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::NodeAnimationTrack *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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Animation *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Animation * >(argp2);
  result = (Ogre::NodeAnimationTrack *)((Ogre::NodeAnimationTrack const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NodeAnimationTrack__applyBaseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::NodeAnimationTrack *arg1 = (Ogre::NodeAnimationTrack *) 0 ;
  Ogre::KeyFrame *arg2 = (Ogre::KeyFrame *) 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_Ogre__NodeAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NodeAnimationTrack *","_applyBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NodeAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::KeyFrame const *","_applyBaseKeyFrame", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::KeyFrame * >(argp2);
  (arg1)->_applyBaseKeyFrame((Ogre::KeyFrame const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassVertexAnimationTrack;

SWIGINTERN VALUE
_wrap_new_VertexAnimationTrack__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::VertexAnimationType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexAnimationTrack";
  Ogre::VertexAnimationTrack *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","Ogre::VertexAnimationTrack", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::VertexAnimationTrack", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::VertexAnimationType","Ogre::VertexAnimationTrack", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::VertexAnimationType >(val3);
  result = (Ogre::VertexAnimationTrack *)new Ogre::VertexAnimationTrack(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_VertexAnimationTrack__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::VertexAnimationType arg3 ;
  Ogre::VertexData *arg4 = (Ogre::VertexData *) 0 ;
  Ogre::VertexAnimationTrack::TargetMode arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexAnimationTrack";
  Ogre::VertexAnimationTrack *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","Ogre::VertexAnimationTrack", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::VertexAnimationTrack", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::VertexAnimationType","Ogre::VertexAnimationTrack", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::VertexAnimationType >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VertexData *","Ogre::VertexAnimationTrack", 4, argv[3] )); 
  }
  arg4 = reinterpret_cast< Ogre::VertexData * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack::TargetMode","Ogre::VertexAnimationTrack", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::VertexAnimationTrack::TargetMode >(val5);
  result = (Ogre::VertexAnimationTrack *)new Ogre::VertexAnimationTrack(arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VertexAnimationTrack__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::VertexAnimationType arg3 ;
  Ogre::VertexData *arg4 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexAnimationTrack";
  Ogre::VertexAnimationTrack *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","Ogre::VertexAnimationTrack", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::VertexAnimationTrack", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::VertexAnimationType","Ogre::VertexAnimationTrack", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::VertexAnimationType >(val3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VertexData *","Ogre::VertexAnimationTrack", 4, argv[3] )); 
  }
  arg4 = reinterpret_cast< Ogre::VertexData * >(argp4);
  result = (Ogre::VertexAnimationTrack *)new Ogre::VertexAnimationTrack(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_VertexAnimationTrack(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(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_VertexAnimationTrack__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_VertexAnimationTrack__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_VertexAnimationTrack__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "VertexAnimationTrack.new", 
    "    VertexAnimationTrack.new(Ogre::Animation *parent, unsigned short handle, Ogre::VertexAnimationType animType)\n"
    "    VertexAnimationTrack.new(Ogre::Animation *parent, unsigned short handle, Ogre::VertexAnimationType animType, Ogre::VertexData *targetData, Ogre::VertexAnimationTrack::TargetMode target)\n"
    "    VertexAnimationTrack.new(Ogre::Animation *parent, unsigned short handle, Ogre::VertexAnimationType animType, Ogre::VertexData *targetData)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_getAnimationType(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexAnimationType 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","getAnimationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  result = (Ogre::VertexAnimationType)((Ogre::VertexAnimationTrack const *)arg1)->getAnimationType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_getVertexAnimationIncludesNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","getVertexAnimationIncludesNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  result = (bool)((Ogre::VertexAnimationTrack const *)arg1)->getVertexAnimationIncludesNormals();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_createVertexMorphKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::VertexMorphKeyFrame *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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","createVertexMorphKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createVertexMorphKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::VertexMorphKeyFrame *)(arg1)->createVertexMorphKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexMorphKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_createVertexPoseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::VertexPoseKeyFrame *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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","createVertexPoseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createVertexPoseKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::VertexPoseKeyFrame *)(arg1)->createVertexPoseKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexPoseKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_getInterpolatedKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::KeyFrame *arg3 = (Ogre::KeyFrame *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","getInterpolatedKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","getInterpolatedKeyFrame", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::KeyFrame *","getInterpolatedKeyFrame", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::KeyFrame * >(argp3);
  ((Ogre::VertexAnimationTrack const *)arg1)->getInterpolatedKeyFrame((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_apply__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_apply__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::TimeIndex *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_apply__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::TimeIndex *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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","apply", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","apply", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TimeIndex * >(argp2);
  (arg1)->apply((Ogre::TimeIndex const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexAnimationTrack_apply(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_Ogre__VertexAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_VertexAnimationTrack_apply__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_VertexAnimationTrack_apply__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 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) {
            return _wrap_VertexAnimationTrack_apply__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "VertexAnimationTrack.apply", 
    "    void VertexAnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::Real scale)\n"
    "    void VertexAnimationTrack.apply(Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void VertexAnimationTrack.apply(Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_applyToVertexData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::PoseList *arg5 = (Ogre::PoseList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","applyToVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","applyToVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToVertexData", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToVertexData", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","applyToVertexData", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::PoseList const *","applyToVertexData", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::PoseList * >(argp5);
  (arg1)->applyToVertexData(arg2,(Ogre::TimeIndex const &)*arg3,arg4,(Ogre::PoseList const *)arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_applyToVertexData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","applyToVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","applyToVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToVertexData", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToVertexData", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","applyToVertexData", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->applyToVertexData(arg2,(Ogre::TimeIndex const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_applyToVertexData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  Ogre::TimeIndex *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","applyToVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","applyToVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TimeIndex,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TimeIndex const &","applyToVertexData", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TimeIndex const &","applyToVertexData", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TimeIndex * >(argp3);
  (arg1)->applyToVertexData(arg2,(Ogre::TimeIndex const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexAnimationTrack_applyToVertexData(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_Ogre__VertexAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexAnimationTrack_applyToVertexData__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_VertexAnimationTrack_applyToVertexData__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexAnimationTrack, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TimeIndex, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_VertexAnimationTrack_applyToVertexData__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "VertexAnimationTrack.applyToVertexData", 
    "    void VertexAnimationTrack.applyToVertexData(Ogre::VertexData *data, Ogre::TimeIndex const &timeIndex, Ogre::Real weight, Ogre::PoseList const *poseList)\n"
    "    void VertexAnimationTrack.applyToVertexData(Ogre::VertexData *data, Ogre::TimeIndex const &timeIndex, Ogre::Real weight)\n"
    "    void VertexAnimationTrack.applyToVertexData(Ogre::VertexData *data, Ogre::TimeIndex const &timeIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_getVertexMorphKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::VertexMorphKeyFrame *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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","getVertexMorphKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(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","getVertexMorphKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::VertexMorphKeyFrame *)((Ogre::VertexAnimationTrack const *)arg1)->getVertexMorphKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexMorphKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_getVertexPoseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::VertexPoseKeyFrame *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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","getVertexPoseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(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","getVertexPoseKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::VertexPoseKeyFrame *)((Ogre::VertexAnimationTrack const *)arg1)->getVertexPoseKeyFrame(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexPoseKeyFrame, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_setAssociatedVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","setAssociatedVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","setAssociatedVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  (arg1)->setAssociatedVertexData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_getAssociatedVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","getAssociatedVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  result = (Ogre::VertexData *)((Ogre::VertexAnimationTrack const *)arg1)->getAssociatedVertexData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_setTargetMode(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::VertexAnimationTrack::TargetMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","setTargetMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack::TargetMode","setTargetMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexAnimationTrack::TargetMode >(val2);
  (arg1)->setTargetMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_getTargetMode(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexAnimationTrack::TargetMode 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","getTargetMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  result = (Ogre::VertexAnimationTrack::TargetMode)((Ogre::VertexAnimationTrack const *)arg1)->getTargetMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_hasNonZeroKeyFrames(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","hasNonZeroKeyFrames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  result = (bool)((Ogre::VertexAnimationTrack const *)arg1)->hasNonZeroKeyFrames();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack_optimise(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","optimise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  (arg1)->optimise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack__clone(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::Animation *arg2 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::VertexAnimationTrack *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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack const *","_clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Animation *","_clone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Animation * >(argp2);
  result = (Ogre::VertexAnimationTrack *)((Ogre::VertexAnimationTrack const *)arg1)->_clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexAnimationTrack__applyBaseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexAnimationTrack *arg1 = (Ogre::VertexAnimationTrack *) 0 ;
  Ogre::KeyFrame *arg2 = (Ogre::KeyFrame *) 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_Ogre__VertexAnimationTrack, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexAnimationTrack *","_applyBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexAnimationTrack * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__KeyFrame, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::KeyFrame const *","_applyBaseKeyFrame", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::KeyFrame * >(argp2);
  (arg1)->_applyBaseKeyFrame((Ogre::KeyFrame const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexAnimationTrack(Ogre::VertexAnimationTrack *arg1) {
    delete arg1;
}

swig_class SwigClassAnimationState;

SWIGINTERN VALUE
_wrap_new_AnimationState__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnimationState";
  Ogre::AnimationState *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",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 &","Ogre::AnimationState", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::AnimationState", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","Ogre::AnimationState", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::AnimationState", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (Ogre::AnimationState *)new Ogre::AnimationState((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_AnimationState__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnimationState";
  Ogre::AnimationState *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",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 &","Ogre::AnimationState", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::AnimationState", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","Ogre::AnimationState", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  result = (Ogre::AnimationState *)new Ogre::AnimationState((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_AnimationState__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnimationState";
  Ogre::AnimationState *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::AnimationState", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::AnimationState", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","Ogre::AnimationState", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AnimationState", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::AnimationState *)new Ogre::AnimationState((Ogre::String const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_AnimationState__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::AnimationState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnimationState";
  Ogre::AnimationState *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__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","Ogre::AnimationState", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__AnimationState,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationState const &","Ogre::AnimationState", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimationState const &","Ogre::AnimationState", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationState * >(argp2);
  result = (Ogre::AnimationState *)new Ogre::AnimationState(arg1,(Ogre::AnimationState const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AnimationState(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AnimationState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_AnimationState__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 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) {
            return _wrap_new_AnimationState__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 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_new_AnimationState__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 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) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_AnimationState__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "AnimationState.new", 
    "    AnimationState.new(Ogre::String const &animName, Ogre::AnimationStateSet *parent, Ogre::Real timePos, Ogre::Real length, Ogre::Real weight, bool enabled)\n"
    "    AnimationState.new(Ogre::String const &animName, Ogre::AnimationStateSet *parent, Ogre::Real timePos, Ogre::Real length, Ogre::Real weight)\n"
    "    AnimationState.new(Ogre::String const &animName, Ogre::AnimationStateSet *parent, Ogre::Real timePos, Ogre::Real length)\n"
    "    AnimationState.new(Ogre::AnimationStateSet *parent, Ogre::AnimationState const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationState(Ogre::AnimationState *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AnimationState_getAnimationName(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getAnimationName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (Ogre::String *) &((Ogre::AnimationState const *)arg1)->getAnimationName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getTimePosition(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getTimePosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (Ogre::Real)((Ogre::AnimationState const *)arg1)->getTimePosition();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_setTimePosition(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","setTimePosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTimePosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTimePosition(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getLength(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (Ogre::Real)((Ogre::AnimationState const *)arg1)->getLength();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_setLength(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","setLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLength", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setLength(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getWeight(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (Ogre::Real)((Ogre::AnimationState const *)arg1)->getWeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_setWeight(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","setWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setWeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setWeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_addTime(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","addTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addTime", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->addTime(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_hasEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","hasEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (bool)((Ogre::AnimationState const *)arg1)->hasEnded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (bool)((Ogre::AnimationState const *)arg1)->getEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_setEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","setEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AnimationState.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_AnimationState___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  Ogre::AnimationState *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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnimationState,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationState const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimationState const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationState * >(argp2);
  result = (bool)((Ogre::AnimationState const *)arg1)->operator ==((Ogre::AnimationState const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_setLoop(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","setLoop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLoop", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLoop(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getLoop(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getLoop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (bool)((Ogre::AnimationState const *)arg1)->getLoop();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_copyStateFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  Ogre::AnimationState *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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","copyStateFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnimationState,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationState const &","copyStateFrom", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimationState const &","copyStateFrom", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationState * >(argp2);
  (arg1)->copyStateFrom((Ogre::AnimationState const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimationStateSet *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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (Ogre::AnimationStateSet *)((Ogre::AnimationState const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_createBlendMask__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  size_t arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","createBlendMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createBlendMask", 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( "", "float","createBlendMask", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->createBlendMask(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_createBlendMask__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","createBlendMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createBlendMask", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->createBlendMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationState_createBlendMask(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_Ogre__AnimationState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnimationState_createBlendMask__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationState, 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) {
          return _wrap_AnimationState_createBlendMask__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "AnimationState.createBlendMask", 
    "    void AnimationState.createBlendMask(size_t blendMaskSizeHint, float initialWeight)\n"
    "    void AnimationState.createBlendMask(size_t blendMaskSizeHint)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_destroyBlendMask(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","destroyBlendMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  (arg1)->destroyBlendMask();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState__setBlendMaskData(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  float *arg2 = (float *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","_setBlendMaskData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float const *","_setBlendMaskData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  (arg1)->_setBlendMaskData((float const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState__setBlendMask(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  Ogre::AnimationState::BoneBlendMask *arg2 = (Ogre::AnimationState::BoneBlendMask *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","_setBlendMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationState::BoneBlendMask const *","_setBlendMask", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationState::BoneBlendMask * >(argp2);
  (arg1)->_setBlendMask((Ogre::AnimationState::BoneBlendMask const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getBlendMask(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimationState::BoneBlendMask *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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getBlendMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (Ogre::AnimationState::BoneBlendMask *)((Ogre::AnimationState const *)arg1)->getBlendMask();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_hasBlendMask(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","hasBlendMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (bool)((Ogre::AnimationState const *)arg1)->hasBlendMask();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_setBlendMaskEntry(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  size_t arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","setBlendMaskEntry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setBlendMaskEntry", 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( "", "float","setBlendMaskEntry", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setBlendMaskEntry(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationState_getBlendMaskEntry(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float 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_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState const *","getBlendMaskEntry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getBlendMaskEntry", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float)((Ogre::AnimationState const *)arg1)->getBlendMaskEntry(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassAnimationStateSet;

SWIGINTERN VALUE
_wrap_new_AnimationStateSet__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::AnimationStateSet";
  Ogre::AnimationStateSet *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::AnimationStateSet *)new Ogre::AnimationStateSet();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_AnimationStateSet__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnimationStateSet";
  Ogre::AnimationStateSet *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__AnimationStateSet,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const &","Ogre::AnimationStateSet", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimationStateSet const &","Ogre::AnimationStateSet", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  result = (Ogre::AnimationStateSet *)new Ogre::AnimationStateSet((Ogre::AnimationStateSet const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AnimationStateSet(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_AnimationStateSet__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AnimationStateSet__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "AnimationStateSet.new", 
    "    AnimationStateSet.new()\n"
    "    AnimationStateSet.new(Ogre::AnimationStateSet const &rhs)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationStateSet(Ogre::AnimationStateSet *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AnimationStateSet_createAnimationState__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::AnimationState *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","createAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(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( "", "Ogre::String const &","createAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimationState", 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","createAnimationState", 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","createAnimationState", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","createAnimationState", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_createAnimationState__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  Ogre::AnimationState *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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","createAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(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( "", "Ogre::String const &","createAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimationState", 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","createAnimationState", 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","createAnimationState", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_createAnimationState__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Ogre::AnimationState *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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","createAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(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( "", "Ogre::String const &","createAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimationState", 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","createAnimationState", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationStateSet_createAnimationState(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 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_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_AnimationStateSet_createAnimationState__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 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_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_AnimationStateSet_createAnimationState__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 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_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) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_AnimationStateSet_createAnimationState__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "AnimationStateSet.createAnimationState", 
    "    Ogre::AnimationState * AnimationStateSet.createAnimationState(Ogre::String const &animName, Ogre::Real timePos, Ogre::Real length, Ogre::Real weight, bool enabled)\n"
    "    Ogre::AnimationState * AnimationStateSet.createAnimationState(Ogre::String const &animName, Ogre::Real timePos, Ogre::Real length, Ogre::Real weight)\n"
    "    Ogre::AnimationState * AnimationStateSet.createAnimationState(Ogre::String const &animName, Ogre::Real timePos, Ogre::Real length)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_getAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::AnimationState *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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const *","getAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(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( "", "Ogre::String const &","getAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::AnimationState *)((Ogre::AnimationStateSet const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_hasAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const *","hasAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(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( "", "Ogre::String const &","hasAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::AnimationStateSet const *)arg1)->hasAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_removeAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","removeAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(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( "", "Ogre::String const &","removeAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeAnimationState((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_removeAllAnimationStates(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","removeAllAnimationStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  (arg1)->removeAllAnimationStates();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_getAnimationStateIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::AnimationStateIterator > 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","getAnimationStateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  result = (arg1)->getAnimationStateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::AnimationStateIterator(static_cast< const Ogre::AnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__AnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_getAnimationStateIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstAnimationStateIterator > 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const *","getAnimationStateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  result = ((Ogre::AnimationStateSet const *)arg1)->getAnimationStateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ConstAnimationStateIterator(static_cast< const Ogre::ConstAnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__ConstAnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationStateSet_getAnimationStateIterator(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_Ogre__AnimationStateSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_AnimationStateSet_getAnimationStateIterator__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationStateSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_AnimationStateSet_getAnimationStateIterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "AnimationStateSet.getAnimationStateIterator", 
    "    Ogre::ConstAnimationStateIterator AnimationStateSet.getAnimationStateIterator()\n"
    "    Ogre::ConstAnimationStateIterator AnimationStateSet.getAnimationStateIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_copyMatchingState(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const *","copyMatchingState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","copyMatchingState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  ((Ogre::AnimationStateSet const *)arg1)->copyMatchingState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet__notifyDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_notifyDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  (arg1)->_notifyDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_getDirtyFrameNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const *","getDirtyFrameNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  result = (unsigned long)((Ogre::AnimationStateSet const *)arg1)->getDirtyFrameNumber();
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet__notifyAnimationStateEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  Ogre::AnimationState *arg2 = (Ogre::AnimationState *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_notifyAnimationStateEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationState *","_notifyAnimationStateEnabled", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationState * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAnimationStateEnabled", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAnimationStateEnabled(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_hasEnabledAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const *","hasEnabledAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  result = (bool)((Ogre::AnimationStateSet const *)arg1)->hasEnabledAnimationState();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_getEnabledAnimationStateIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstEnabledAnimationStateIterator > 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const *","getEnabledAnimationStateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  result = ((Ogre::AnimationStateSet const *)arg1)->getEnabledAnimationStateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ConstEnabledAnimationStateIterator(static_cast< const Ogre::ConstEnabledAnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__ConstEnabledAnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateSet_each_AnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateSet *arg1 = (Ogre::AnimationStateSet *) 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_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","each_AnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateSet * >(argp1);
  Ogre_AnimationStateSet_each_AnimationState(arg1);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassAnimationStateControllerValue;

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

SWIGINTERN VALUE
_wrap_new_AnimationStateControllerValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationState *arg1 = (Ogre::AnimationState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnimationStateControllerValue";
  Ogre::AnimationStateControllerValue *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__AnimationState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationState *","Ogre::AnimationStateControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationState * >(argp1);
  result = (Ogre::AnimationStateControllerValue *)new Ogre::AnimationStateControllerValue(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationStateControllerValue(Ogre::AnimationStateControllerValue *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AnimationStateControllerValue_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateControllerValue *arg1 = (Ogre::AnimationStateControllerValue *) 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_Ogre__AnimationStateControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateControllerValue const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::AnimationStateControllerValue const *)arg1)->getValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationStateControllerValue_setValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationStateControllerValue *arg1 = (Ogre::AnimationStateControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimationStateControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationStateControllerValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationStateControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassAnimationContainer;

SWIGINTERN VALUE
_wrap_AnimationContainer_getNumAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationContainer *arg1 = (Ogre::AnimationContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__AnimationContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationContainer const *","getNumAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationContainer * >(argp1);
  result = (unsigned short)((Ogre::AnimationContainer const *)arg1)->getNumAnimations();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationContainer_getAnimation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationContainer *arg1 = (Ogre::AnimationContainer *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Animation *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_Ogre__AnimationContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationContainer const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationContainer * >(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","getAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Animation *)((Ogre::AnimationContainer const *)arg1)->getAnimation(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationContainer_getAnimation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationContainer *arg1 = (Ogre::AnimationContainer *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__AnimationContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationContainer const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationContainer * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::AnimationContainer const *)arg1)->getAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_AnimationContainer_getAnimation(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_Ogre__AnimationContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_AnimationContainer_getAnimation__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AnimationContainer, 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_AnimationContainer_getAnimation__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AnimationContainer.getAnimation", 
    "    Ogre::Animation * AnimationContainer.getAnimation(unsigned short index)\n"
    "    Ogre::Animation * AnimationContainer.getAnimation(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationContainer_createAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationContainer *arg1 = (Ogre::AnimationContainer *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Animation *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_Ogre__AnimationContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationContainer *","createAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationContainer * >(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( "", "Ogre::String const &","createAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationContainer_hasAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationContainer *arg1 = (Ogre::AnimationContainer *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__AnimationContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationContainer const *","hasAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationContainer * >(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( "", "Ogre::String const &","hasAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::AnimationContainer const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationContainer_removeAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationContainer *arg1 = (Ogre::AnimationContainer *) 0 ;
  Ogre::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_Ogre__AnimationContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationContainer *","removeAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationContainer * >(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( "", "Ogre::String const &","removeAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeAnimation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationContainer(Ogre::AnimationContainer *arg1) {
    delete arg1;
}

swig_class SwigClassAnimation;

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

SWIGINTERN VALUE
_wrap_new_Animation(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Real arg2 ;
  int res1 = SWIG_OLDOBJ ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Animation";
  Ogre::Animation *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::Animation", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Animation", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Animation", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Animation *)new Ogre::Animation((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_Animation(Ogre::Animation *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Animation_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::String *) &((Ogre::Animation const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getLength(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::Real)((Ogre::Animation const *)arg1)->getLength();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setLength(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","setLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLength", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setLength(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_createNodeTrack__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::NodeAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","createNodeTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","createNodeTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::NodeAnimationTrack *)(arg1)->createNodeTrack(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_createNumericTrack__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::NumericAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","createNumericTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","createNumericTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::NumericAnimationTrack *)(arg1)->createNumericTrack(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_createVertexTrack__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::VertexAnimationType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Ogre::VertexAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","createVertexTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","createVertexTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::VertexAnimationType","createVertexTrack", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::VertexAnimationType >(val3);
  result = (Ogre::VertexAnimationTrack *)(arg1)->createVertexTrack(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_createNodeTrack__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::Node *arg3 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::NodeAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","createNodeTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","createNodeTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Node *","createNodeTrack", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Node * >(argp3);
  result = (Ogre::NodeAnimationTrack *)(arg1)->createNodeTrack(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_createNodeTrack(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Animation_createNodeTrack__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Node, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Animation_createNodeTrack__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Animation.createNodeTrack", 
    "    Ogre::NodeAnimationTrack * Animation.createNodeTrack(unsigned short handle)\n"
    "    Ogre::NodeAnimationTrack * Animation.createNodeTrack(unsigned short handle, Ogre::Node *node)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_createNumericTrack__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::AnimableValuePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::NumericAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","createNumericTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","createNumericTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","createNumericTrack", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","createNumericTrack", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp3);
  result = (Ogre::NumericAnimationTrack *)(arg1)->createNumericTrack(arg2,(Ogre::AnimableValuePtr const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_createNumericTrack(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Animation_createNumericTrack__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Animation_createNumericTrack__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Animation.createNumericTrack", 
    "    Ogre::NumericAnimationTrack * Animation.createNumericTrack(unsigned short handle)\n"
    "    Ogre::NumericAnimationTrack * Animation.createNumericTrack(unsigned short handle, Ogre::AnimableValuePtr const &anim)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_createVertexTrack__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  Ogre::VertexData *arg3 = (Ogre::VertexData *) 0 ;
  Ogre::VertexAnimationType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::VertexAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","createVertexTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","createVertexTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexData *","createVertexTrack", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexData * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::VertexAnimationType","createVertexTrack", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::VertexAnimationType >(val4);
  result = (Ogre::VertexAnimationTrack *)(arg1)->createVertexTrack(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_createVertexTrack(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(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_Animation_createVertexTrack__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Animation_createVertexTrack__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Animation.createVertexTrack", 
    "    Ogre::VertexAnimationTrack * Animation.createVertexTrack(unsigned short handle, Ogre::VertexAnimationType animType)\n"
    "    Ogre::VertexAnimationTrack * Animation.createVertexTrack(unsigned short handle, Ogre::VertexData *data, Ogre::VertexAnimationType animType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getNumNodeTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getNumNodeTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (unsigned short)((Ogre::Animation const *)arg1)->getNumNodeTracks();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getNodeTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::NodeAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getNodeTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","getNodeTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::NodeAnimationTrack *)((Ogre::Animation const *)arg1)->getNodeTrack(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NodeAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_hasNodeTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","hasNodeTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","hasNodeTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (bool)((Ogre::Animation const *)arg1)->hasNodeTrack(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getNumNumericTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getNumNumericTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (unsigned short)((Ogre::Animation const *)arg1)->getNumNumericTracks();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getNumericTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::NumericAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getNumericTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","getNumericTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::NumericAnimationTrack *)((Ogre::Animation const *)arg1)->getNumericTrack(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__NumericAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_hasNumericTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","hasNumericTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","hasNumericTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (bool)((Ogre::Animation const *)arg1)->hasNumericTrack(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getNumVertexTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getNumVertexTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (unsigned short)((Ogre::Animation const *)arg1)->getNumVertexTracks();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getVertexTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::VertexAnimationTrack *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getVertexTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","getVertexTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::VertexAnimationTrack *)((Ogre::Animation const *)arg1)->getVertexTrack(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexAnimationTrack, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_hasVertexTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","hasVertexTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","hasVertexTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (bool)((Ogre::Animation const *)arg1)->hasVertexTrack(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_destroyNodeTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","destroyNodeTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","destroyNodeTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->destroyNodeTrack(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_destroyNumericTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","destroyNumericTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","destroyNumericTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->destroyNumericTrack(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_destroyVertexTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","destroyVertexTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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","destroyVertexTrack", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->destroyVertexTrack(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_destroyAllTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","destroyAllTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  (arg1)->destroyAllTracks();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_destroyAllNodeTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","destroyAllNodeTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  (arg1)->destroyAllNodeTracks();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_destroyAllNumericTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","destroyAllNumericTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  (arg1)->destroyAllNumericTracks();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_destroyAllVertexTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","destroyAllVertexTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  (arg1)->destroyAllVertexTracks();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 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","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->apply(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->apply(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","apply", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->apply(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToNode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","applyToNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToNode", 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","applyToNode", 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","applyToNode", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->applyToNode(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToNode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","applyToNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToNode", 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","applyToNode", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->applyToNode(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToNode__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","applyToNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToNode", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->applyToNode(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_applyToNode(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Animation_applyToNode__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 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) {
            return _wrap_Animation_applyToNode__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 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_Animation_applyToNode__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Animation.applyToNode", 
    "    void Animation.applyToNode(Ogre::Node *node, Ogre::Real timePos, Ogre::Real weight, Ogre::Real scale)\n"
    "    void Animation.applyToNode(Ogre::Node *node, Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.applyToNode(Ogre::Node *node, Ogre::Real timePos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton *","apply", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 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","apply", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->apply(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton *","apply", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->apply(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton *","apply", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->apply(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Real arg3 ;
  float arg4 ;
  Ogre::AnimationState::BoneBlendMask *arg5 = (Ogre::AnimationState::BoneBlendMask *) 0 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton *","apply", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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( "", "float","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::AnimationState::BoneBlendMask const *","apply", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::AnimationState::BoneBlendMask * >(argp5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","apply", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->apply(arg2,arg3,arg4,(Ogre::AnimationState::BoneBlendMask const *)arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_apply__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","apply", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","apply", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","apply", 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","apply", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","apply", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","apply", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->apply(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_apply(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Animation_apply__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Animation_apply__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 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_Animation_apply__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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) {
            return _wrap_Animation_apply__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 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_Animation_apply__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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_Animation_apply__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Animation_apply__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 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_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Animation_apply__SWIG_7(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Animation.apply", 
    "    void Animation.apply(Ogre::Real timePos, Ogre::Real weight, Ogre::Real scale)\n"
    "    void Animation.apply(Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.apply(Ogre::Real timePos)\n"
    "    void Animation.apply(Ogre::Skeleton *skeleton, Ogre::Real timePos, Ogre::Real weight, Ogre::Real scale)\n"
    "    void Animation.apply(Ogre::Skeleton *skeleton, Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.apply(Ogre::Skeleton *skeleton, Ogre::Real timePos)\n"
    "    void Animation.apply(Ogre::Skeleton *skeleton, Ogre::Real timePos, float weight, Ogre::AnimationState::BoneBlendMask const *blendMask, Ogre::Real scale)\n"
    "    void Animation.apply(Ogre::Entity *entity, Ogre::Real timePos, Ogre::Real weight, bool software, bool hardware)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToAnimable__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::AnimableValuePtr *arg2 = 0 ;
  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 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToAnimable", 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","applyToAnimable", 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","applyToAnimable", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToAnimable__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::AnimableValuePtr *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToAnimable", 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","applyToAnimable", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToAnimable__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::AnimableValuePtr *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToAnimable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimableValuePtr const &","applyToAnimable", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimableValuePtr * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToAnimable", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->applyToAnimable((Ogre::AnimableValuePtr const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_applyToAnimable(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Animation_applyToAnimable__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 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) {
            return _wrap_Animation_applyToAnimable__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, 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_Animation_applyToAnimable__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Animation.applyToAnimable", 
    "    void Animation.applyToAnimable(Ogre::AnimableValuePtr const &anim, Ogre::Real timePos, Ogre::Real weight, Ogre::Real scale)\n"
    "    void Animation.applyToAnimable(Ogre::AnimableValuePtr const &anim, Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.applyToAnimable(Ogre::AnimableValuePtr const &anim, Ogre::Real timePos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToVertexData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","applyToVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToVertexData", 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","applyToVertexData", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->applyToVertexData(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_applyToVertexData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","applyToVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","applyToVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","applyToVertexData", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->applyToVertexData(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_applyToVertexData(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Animation_applyToVertexData__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexData, 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) {
            return _wrap_Animation_applyToVertexData__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Animation.applyToVertexData", 
    "    void Animation.applyToVertexData(Ogre::VertexData *data, Ogre::Real timePos, Ogre::Real weight)\n"
    "    void Animation.applyToVertexData(Ogre::VertexData *data, Ogre::Real timePos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Animation::InterpolationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","setInterpolationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Animation::InterpolationMode","setInterpolationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Animation::InterpolationMode >(val2);
  (arg1)->setInterpolationMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Animation::InterpolationMode 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getInterpolationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::Animation::InterpolationMode)((Ogre::Animation const *)arg1)->getInterpolationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setRotationInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Animation::RotationInterpolationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","setRotationInterpolationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Animation::RotationInterpolationMode","setRotationInterpolationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Animation::RotationInterpolationMode >(val2);
  (arg1)->setRotationInterpolationMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getRotationInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Animation::RotationInterpolationMode 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getRotationInterpolationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::Animation::RotationInterpolationMode)((Ogre::Animation const *)arg1)->getRotationInterpolationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setDefaultInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation::InterpolationMode arg1 ;
  int val1 ;
  int ecode1 = 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( "", "Ogre::Animation::InterpolationMode","Ogre::Animation::setDefaultInterpolationMode", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Animation::InterpolationMode >(val1);
  Ogre::Animation::setDefaultInterpolationMode(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getDefaultInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation::InterpolationMode result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Animation::InterpolationMode)Ogre::Animation::getDefaultInterpolationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setDefaultRotationInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation::RotationInterpolationMode arg1 ;
  int val1 ;
  int ecode1 = 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( "", "Ogre::Animation::RotationInterpolationMode","Ogre::Animation::setDefaultRotationInterpolationMode", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Animation::RotationInterpolationMode >(val1);
  Ogre::Animation::setDefaultRotationInterpolationMode(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getDefaultRotationInterpolationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation::RotationInterpolationMode result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Animation::RotationInterpolationMode)Ogre::Animation::getDefaultRotationInterpolationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__getNodeTrackList(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Animation::NodeTrackList *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","_getNodeTrackList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::Animation::NodeTrackList *) &((Ogre::Animation const *)arg1)->_getNodeTrackList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getNodeTrackIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< unsigned short,Ogre::NodeAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::NodeAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getNodeTrackIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = ((Ogre::Animation const *)arg1)->getNodeTrackIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Animation::NodeTrackIterator(static_cast< const Ogre::Animation::NodeTrackIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__getNumericTrackList(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Animation::NumericTrackList *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","_getNumericTrackList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::Animation::NumericTrackList *) &((Ogre::Animation const *)arg1)->_getNumericTrackList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getNumericTrackIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< unsigned short,Ogre::NumericAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::NumericAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getNumericTrackIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = ((Ogre::Animation const *)arg1)->getNumericTrackIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Animation::NumericTrackIterator(static_cast< const Ogre::Animation::NumericTrackIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__getVertexTrackList(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Animation::VertexTrackList *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","_getVertexTrackList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::Animation::VertexTrackList *) &((Ogre::Animation const *)arg1)->_getVertexTrackList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getVertexTrackIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< unsigned short,Ogre::VertexAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::VertexAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getVertexTrackIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = ((Ogre::Animation const *)arg1)->getVertexTrackIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Animation::VertexTrackIterator(static_cast< const Ogre::Animation::VertexTrackIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_optimise__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","optimise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","optimise", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->optimise(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_optimise__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","optimise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  (arg1)->optimise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_optimise(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Animation_optimise__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Animation_optimise__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Animation.optimise", 
    "    void Animation.optimise(bool discardIdentityNodeTracks)\n"
    "    void Animation.optimise()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__collectIdentityNodeTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Animation::TrackHandleList *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","_collectIdentityNodeTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Animation::TrackHandleList &","_collectIdentityNodeTracks", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Animation::TrackHandleList &","_collectIdentityNodeTracks", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Animation::TrackHandleList * >(argp2);
  ((Ogre::Animation const *)arg1)->_collectIdentityNodeTracks(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__destroyNodeTracks(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Animation::TrackHandleList *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","_destroyNodeTracks", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Animation::TrackHandleList const &","_destroyNodeTracks", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Animation::TrackHandleList const &","_destroyNodeTracks", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Animation::TrackHandleList * >(argp2);
  (arg1)->_destroyNodeTracks((Ogre::Animation::TrackHandleList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Animation.clone

  call-seq:
    clone(newName) -> Animation

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_Animation_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::Animation const *)arg1)->clone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__keyFrameListChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","_keyFrameListChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  (arg1)->_keyFrameListChanged();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__getTimeIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::TimeIndex > 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","_getTimeIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_getTimeIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Animation const *)arg1)->_getTimeIndex(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::TimeIndex(static_cast< const Ogre::TimeIndex& >(result))), SWIGTYPE_p_Ogre__TimeIndex, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setUseBaseKeyFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  bool arg2 ;
  Ogre::Real arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","setUseBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseBaseKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setUseBaseKeyFrame", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setUseBaseKeyFrame", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setUseBaseKeyFrame", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->setUseBaseKeyFrame(arg2,arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setUseBaseKeyFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  bool arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","setUseBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseBaseKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setUseBaseKeyFrame", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setUseBaseKeyFrame(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_setUseBaseKeyFrame__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","setUseBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseBaseKeyFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseBaseKeyFrame(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Animation_setUseBaseKeyFrame(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_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Animation_setUseBaseKeyFrame__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Animation_setUseBaseKeyFrame__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Animation, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Animation_setUseBaseKeyFrame__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Animation.setUseBaseKeyFrame", 
    "    void Animation.setUseBaseKeyFrame(bool useBaseKeyFrame, Ogre::Real keyframeTime, Ogre::String const &baseAnimName)\n"
    "    void Animation.setUseBaseKeyFrame(bool useBaseKeyFrame, Ogre::Real keyframeTime)\n"
    "    void Animation.setUseBaseKeyFrame(bool useBaseKeyFrame)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getUseBaseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getUseBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (bool)((Ogre::Animation const *)arg1)->getUseBaseKeyFrame();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getBaseKeyFrameTime(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getBaseKeyFrameTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::Real)((Ogre::Animation const *)arg1)->getBaseKeyFrameTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getBaseKeyFrameAnimationName(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation const *","getBaseKeyFrameAnimationName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::String *) &((Ogre::Animation const *)arg1)->getBaseKeyFrameAnimationName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__applyBaseKeyFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","_applyBaseKeyFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  (arg1)->_applyBaseKeyFrame();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation__notifyContainer(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  Ogre::AnimationContainer *arg2 = (Ogre::AnimationContainer *) 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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","_notifyContainer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationContainer *","_notifyContainer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationContainer * >(argp2);
  (arg1)->_notifyContainer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Animation_getContainer(int argc, VALUE *argv, VALUE self) {
  Ogre::Animation *arg1 = (Ogre::Animation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimationContainer *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_Ogre__Animation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Animation *","getContainer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Animation * >(argp1);
  result = (Ogre::AnimationContainer *)(arg1)->getContainer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationContainer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDataStream;

SWIGINTERN VALUE
_wrap_DataStream_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (Ogre::String *) &(arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_getAccessMode(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream const *","getAccessMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (Ogre::uint16)((Ogre::DataStream const *)arg1)->getAccessMode();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_isReadable(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream const *","isReadable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (bool)((Ogre::DataStream const *)arg1)->isReadable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_isWriteable(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream const *","isWriteable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (bool)((Ogre::DataStream const *)arg1)->isWriteable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DataStream(Ogre::DataStream *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DataStream_read(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","read", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->read(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_write(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","write", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->write((void const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_readLine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  size_t 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","readLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","readLine", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readLine", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","readLine", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","readLine", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (arg1)->readLine(arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_readLine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","readLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","readLine", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readLine", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->readLine(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_DataStream_readLine(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_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_DataStream_readLine__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DataStream_readLine__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "DataStream.readLine", 
    "    size_t DataStream.readLine(char *buf, size_t maxCount, Ogre::String const &delim)\n"
    "    size_t DataStream.readLine(char *buf, size_t maxCount)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_getLine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","getLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getLine", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->getLine(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_getLine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","getLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (arg1)->getLine();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DataStream_getLine(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_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DataStream_getLine__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_DataStream_getLine__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "DataStream.getLine", 
    "    Ogre::String DataStream.getLine(bool trimAfter)\n"
    "    Ogre::String DataStream.getLine()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_getAsString(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","getAsString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (arg1)->getAsString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_skipLine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","skipLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(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( "", "Ogre::String const &","skipLine", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","skipLine", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->skipLine((Ogre::String const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_skipLine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","skipLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (arg1)->skipLine();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DataStream_skipLine(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_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DataStream_skipLine__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DataStream, 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_DataStream_skipLine__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "DataStream.skipLine", 
    "    size_t DataStream.skipLine(Ogre::String const &delim)\n"
    "    size_t DataStream.skipLine()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_skip(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","skip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","skip", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->skip(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_seek(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","seek", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","seek", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->seek(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_tell(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream const *","tell", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = ((Ogre::DataStream const *)arg1)->tell();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_eof(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream const *","eof", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (bool)((Ogre::DataStream const *)arg1)->eof();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::DataStream.size

  call-seq:
    size -> size_t

Size or Length of the DataStream.
*/
SWIGINTERN VALUE
_wrap_DataStream_size(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = ((Ogre::DataStream const *)arg1)->size();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DataStream_close(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = (Ogre::DataStream *) 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_Ogre__DataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  (arg1)->close();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMemoryDataStream;

SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  size_t arg2 ;
  bool arg3 ;
  bool arg4 ;
  int res1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  size_t arg2 ;
  bool arg3 ;
  int res1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  size_t arg2 ;
  int res1 ;
  size_t val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *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],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  bool arg4 ;
  bool arg5 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__DataStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream &","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStream &","Ogre::MemoryDataStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *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__DataStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream &","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStream &","Ogre::MemoryDataStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStream *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *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__DataStream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStream &","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStream &","Ogre::MemoryDataStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStream * >(argp1);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","Ogre::MemoryDataStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *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__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","Ogre::MemoryDataStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *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__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","Ogre::MemoryDataStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","Ogre::MemoryDataStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStream *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__DataStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStream &","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStream &","Ogre::MemoryDataStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStream * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,*arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_13(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStream *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__DataStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStream &","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStream &","Ogre::MemoryDataStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStream * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,*arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_14(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStream *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__DataStream,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStream &","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStream &","Ogre::MemoryDataStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStream * >(argp2);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_15(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::MemoryDataStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_16(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::MemoryDataStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_17(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::MemoryDataStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::MemoryDataStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_18(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  bool arg2 ;
  bool arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_19(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  bool arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_20(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_21(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  bool arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_22(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::MemoryDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MemoryDataStream__SWIG_23(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MemoryDataStream";
  Ogre::MemoryDataStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::MemoryDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MemoryDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::MemoryDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::MemoryDataStream *)new Ogre::MemoryDataStream((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MemoryDataStream(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MemoryDataStream__SWIG_8(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MemoryDataStream__SWIG_11(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_MemoryDataStream__SWIG_20(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MemoryDataStream__SWIG_10(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MemoryDataStream__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *ptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MemoryDataStream__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(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_MemoryDataStream__SWIG_19(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MemoryDataStream__SWIG_14(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_MemoryDataStream__SWIG_17(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MemoryDataStream__SWIG_23(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_9(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *ptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_18(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_16(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_13(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_MemoryDataStream__SWIG_22(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *ptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MemoryDataStream__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__DataStream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MemoryDataStream__SWIG_12(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MemoryDataStream__SWIG_15(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MemoryDataStream__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_MemoryDataStream__SWIG_21(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_MemoryDataStream__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MemoryDataStream.new", 
    "    MemoryDataStream.new(void *pMem, size_t size, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(void *pMem, size_t size, bool freeOnClose)\n"
    "    MemoryDataStream.new(void *pMem, size_t size)\n"
    "    MemoryDataStream.new(Ogre::String const &name, void *pMem, size_t size, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(Ogre::String const &name, void *pMem, size_t size, bool freeOnClose)\n"
    "    MemoryDataStream.new(Ogre::String const &name, void *pMem, size_t size)\n"
    "    MemoryDataStream.new(Ogre::DataStream &sourceStream, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(Ogre::DataStream &sourceStream, bool freeOnClose)\n"
    "    MemoryDataStream.new(Ogre::DataStream &sourceStream)\n"
    "    MemoryDataStream.new(Ogre::DataStreamPtr &sourceStream, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(Ogre::DataStreamPtr &sourceStream, bool freeOnClose)\n"
    "    MemoryDataStream.new(Ogre::DataStreamPtr &sourceStream)\n"
    "    MemoryDataStream.new(Ogre::String const &name, Ogre::DataStream &sourceStream, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(Ogre::String const &name, Ogre::DataStream &sourceStream, bool freeOnClose)\n"
    "    MemoryDataStream.new(Ogre::String const &name, Ogre::DataStream &sourceStream)\n"
    "    MemoryDataStream.new(Ogre::String const &name, Ogre::DataStreamPtr const &sourceStream, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(Ogre::String const &name, Ogre::DataStreamPtr const &sourceStream, bool freeOnClose)\n"
    "    MemoryDataStream.new(Ogre::String const &name, Ogre::DataStreamPtr const &sourceStream)\n"
    "    MemoryDataStream.new(size_t size, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(size_t size, bool freeOnClose)\n"
    "    MemoryDataStream.new(size_t size)\n"
    "    MemoryDataStream.new(Ogre::String const &name, size_t size, bool freeOnClose, bool readOnly)\n"
    "    MemoryDataStream.new(Ogre::String const &name, size_t size, bool freeOnClose)\n"
    "    MemoryDataStream.new(Ogre::String const &name, size_t size)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_MemoryDataStream(Ogre::MemoryDataStream *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MemoryDataStream_getPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uchar *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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","getPtr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  result = (Ogre::uchar *)(arg1)->getPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_getCurrentPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uchar *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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","getCurrentPtr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  result = (Ogre::uchar *)(arg1)->getCurrentPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_read(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","read", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->read(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_write(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","write", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->write((void const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_readLine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  size_t 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","readLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","readLine", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readLine", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","readLine", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","readLine", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (arg1)->readLine(arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_readLine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","readLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","readLine", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readLine", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->readLine(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MemoryDataStream_readLine(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_Ogre__MemoryDataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MemoryDataStream_readLine__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MemoryDataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MemoryDataStream_readLine__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MemoryDataStream.readLine", 
    "    size_t MemoryDataStream.readLine(char *buf, size_t maxCount, Ogre::String const &delim)\n"
    "    size_t MemoryDataStream.readLine(char *buf, size_t maxCount)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_skipLine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","skipLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(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( "", "Ogre::String const &","skipLine", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","skipLine", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->skipLine((Ogre::String const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_skipLine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","skipLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  result = (arg1)->skipLine();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MemoryDataStream_skipLine(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_Ogre__MemoryDataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MemoryDataStream_skipLine__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MemoryDataStream, 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_MemoryDataStream_skipLine__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MemoryDataStream.skipLine", 
    "    size_t MemoryDataStream.skipLine(Ogre::String const &delim)\n"
    "    size_t MemoryDataStream.skipLine()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_skip(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","skip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","skip", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->skip(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_seek(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","seek", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","seek", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->seek(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_tell(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream const *","tell", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  result = ((Ogre::MemoryDataStream const *)arg1)->tell();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_eof(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream const *","eof", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  result = (bool)((Ogre::MemoryDataStream const *)arg1)->eof();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_close(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  (arg1)->close();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MemoryDataStream_setFreeOnClose(int argc, VALUE *argv, VALUE self) {
  Ogre::MemoryDataStream *arg1 = (Ogre::MemoryDataStream *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MemoryDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MemoryDataStream *","setFreeOnClose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MemoryDataStream * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFreeOnClose", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFreeOnClose(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassFileStreamDataStream;

SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  std::ifstream *arg1 = (std::ifstream *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *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_std__ifstream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ifstream *","Ogre::FileStreamDataStream", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< std::ifstream * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::FileStreamDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::ifstream *arg1 = (std::ifstream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *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_std__ifstream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ifstream *","Ogre::FileStreamDataStream", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< std::ifstream * >(argp1);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::fstream *arg1 = (std::fstream *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *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_std__fstream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::fstream *","Ogre::FileStreamDataStream", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< std::fstream * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::FileStreamDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_3(int argc, VALUE *argv, VALUE self) {
  std::fstream *arg1 = (std::fstream *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *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_std__fstream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::fstream *","Ogre::FileStreamDataStream", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< std::fstream * >(argp1);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::ifstream *arg2 = (std::ifstream *) 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__ifstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::ifstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::ifstream * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::FileStreamDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::ifstream *arg2 = (std::ifstream *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__ifstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::ifstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::ifstream * >(argp2);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::fstream *arg2 = (std::fstream *) 0 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__fstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::fstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::fstream * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::FileStreamDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::fstream *arg2 = (std::fstream *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__fstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::fstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::fstream * >(argp2);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::ifstream *arg2 = (std::ifstream *) 0 ;
  size_t arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__ifstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::ifstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::ifstream * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::FileStreamDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::FileStreamDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::ifstream *arg2 = (std::ifstream *) 0 ;
  size_t arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__ifstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::ifstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::ifstream * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::FileStreamDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::fstream *arg2 = (std::fstream *) 0 ;
  size_t arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__fstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::fstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::fstream * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::FileStreamDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::FileStreamDataStream", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_FileStreamDataStream__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  std::fstream *arg2 = (std::fstream *) 0 ;
  size_t arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileStreamDataStream";
  Ogre::FileStreamDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::FileStreamDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileStreamDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_std__fstream, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::fstream *","Ogre::FileStreamDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< std::fstream * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::FileStreamDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::FileStreamDataStream *)new Ogre::FileStreamDataStream((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FileStreamDataStream(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ifstream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileStreamDataStream__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__fstream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileStreamDataStream__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__fstream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FileStreamDataStream__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__ifstream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FileStreamDataStream__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ifstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileStreamDataStream__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__fstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileStreamDataStream__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__fstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FileStreamDataStream__SWIG_11(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ifstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FileStreamDataStream__SWIG_9(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ifstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FileStreamDataStream__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__fstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FileStreamDataStream__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__fstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FileStreamDataStream__SWIG_10(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__ifstream, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_FileStreamDataStream__SWIG_8(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FileStreamDataStream.new", 
    "    FileStreamDataStream.new(std::ifstream *s, bool freeOnClose)\n"
    "    FileStreamDataStream.new(std::ifstream *s)\n"
    "    FileStreamDataStream.new(std::fstream *s, bool freeOnClose)\n"
    "    FileStreamDataStream.new(std::fstream *s)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::ifstream *s, bool freeOnClose)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::ifstream *s)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::fstream *s, bool freeOnClose)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::fstream *s)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::ifstream *s, size_t size, bool freeOnClose)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::ifstream *s, size_t size)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::fstream *s, size_t size, bool freeOnClose)\n"
    "    FileStreamDataStream.new(Ogre::String const &name, std::fstream *s, size_t size)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_FileStreamDataStream(Ogre::FileStreamDataStream *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FileStreamDataStream_read(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","read", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->read(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_write(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","write", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->write((void const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_readLine__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  size_t 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream *","readLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","readLine", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readLine", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","readLine", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","readLine", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (arg1)->readLine(arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_readLine__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream *","readLine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char *","readLine", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readLine", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->readLine(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_FileStreamDataStream_readLine(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_Ogre__FileStreamDataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileStreamDataStream_readLine__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileStreamDataStream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_FileStreamDataStream_readLine__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FileStreamDataStream.readLine", 
    "    size_t FileStreamDataStream.readLine(char *buf, size_t maxCount, Ogre::String const &delim)\n"
    "    size_t FileStreamDataStream.readLine(char *buf, size_t maxCount)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_skip(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream *","skip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","skip", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->skip(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_seek(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream *","seek", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","seek", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->seek(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_tell(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream const *","tell", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  result = ((Ogre::FileStreamDataStream const *)arg1)->tell();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_eof(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream const *","eof", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  result = (bool)((Ogre::FileStreamDataStream const *)arg1)->eof();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileStreamDataStream_close(int argc, VALUE *argv, VALUE self) {
  Ogre::FileStreamDataStream *arg1 = (Ogre::FileStreamDataStream *) 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_Ogre__FileStreamDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileStreamDataStream *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileStreamDataStream * >(argp1);
  (arg1)->close();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassFileHandleDataStream;

SWIGINTERN VALUE
_wrap_new_FileHandleDataStream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  FILE *arg1 = (FILE *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileHandleDataStream";
  Ogre::FileHandleDataStream *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_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","Ogre::FileHandleDataStream", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::FileHandleDataStream", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileHandleDataStream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  FILE *arg1 = (FILE *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileHandleDataStream";
  Ogre::FileHandleDataStream *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_FILE, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "FILE *","Ogre::FileHandleDataStream", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< FILE * >(argp1);
  result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FileHandleDataStream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  FILE *arg2 = (FILE *) 0 ;
  Ogre::uint16 arg3 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileHandleDataStream";
  Ogre::FileHandleDataStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::FileHandleDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileHandleDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FILE *","Ogre::FileHandleDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< FILE * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::FileHandleDataStream", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_FileHandleDataStream__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  FILE *arg2 = (FILE *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FileHandleDataStream";
  Ogre::FileHandleDataStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::FileHandleDataStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileHandleDataStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_FILE, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "FILE *","Ogre::FileHandleDataStream", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< FILE * >(argp2);
  result = (Ogre::FileHandleDataStream *)new Ogre::FileHandleDataStream((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FileHandleDataStream(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FILE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FileHandleDataStream__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_FILE, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_FileHandleDataStream__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_FileHandleDataStream__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_FILE, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_FileHandleDataStream__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "FileHandleDataStream.new", 
    "    FileHandleDataStream.new(FILE *handle, Ogre::uint16 accessMode)\n"
    "    FileHandleDataStream.new(FILE *handle)\n"
    "    FileHandleDataStream.new(Ogre::String const &name, FILE *handle, Ogre::uint16 accessMode)\n"
    "    FileHandleDataStream.new(Ogre::String const &name, FILE *handle)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_FileHandleDataStream(Ogre::FileHandleDataStream *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FileHandleDataStream_read(int argc, VALUE *argv, VALUE self) {
  Ogre::FileHandleDataStream *arg1 = (Ogre::FileHandleDataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__FileHandleDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileHandleDataStream *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileHandleDataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","read", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->read(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileHandleDataStream_write(int argc, VALUE *argv, VALUE self) {
  Ogre::FileHandleDataStream *arg1 = (Ogre::FileHandleDataStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__FileHandleDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileHandleDataStream *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileHandleDataStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","write", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->write((void const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileHandleDataStream_skip(int argc, VALUE *argv, VALUE self) {
  Ogre::FileHandleDataStream *arg1 = (Ogre::FileHandleDataStream *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long 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_Ogre__FileHandleDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileHandleDataStream *","skip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileHandleDataStream * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","skip", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->skip(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileHandleDataStream_seek(int argc, VALUE *argv, VALUE self) {
  Ogre::FileHandleDataStream *arg1 = (Ogre::FileHandleDataStream *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__FileHandleDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileHandleDataStream *","seek", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileHandleDataStream * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","seek", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->seek(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileHandleDataStream_tell(int argc, VALUE *argv, VALUE self) {
  Ogre::FileHandleDataStream *arg1 = (Ogre::FileHandleDataStream *) 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_Ogre__FileHandleDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileHandleDataStream const *","tell", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileHandleDataStream * >(argp1);
  result = ((Ogre::FileHandleDataStream const *)arg1)->tell();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileHandleDataStream_eof(int argc, VALUE *argv, VALUE self) {
  Ogre::FileHandleDataStream *arg1 = (Ogre::FileHandleDataStream *) 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_Ogre__FileHandleDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileHandleDataStream const *","eof", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileHandleDataStream * >(argp1);
  result = (bool)((Ogre::FileHandleDataStream const *)arg1)->eof();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileHandleDataStream_close(int argc, VALUE *argv, VALUE self) {
  Ogre::FileHandleDataStream *arg1 = (Ogre::FileHandleDataStream *) 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_Ogre__FileHandleDataStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileHandleDataStream *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileHandleDataStream * >(argp1);
  (arg1)->close();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassFileInfo;

SWIGINTERN VALUE
_wrap_FileInfo_archive_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  Ogre::Archive *arg2 = (Ogre::Archive *) 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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","archive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Archive, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Archive const *","archive", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Archive * >(argp2);
  if (arg1) (arg1)->archive = (Ogre::Archive const *)arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_archive_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Archive *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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","archive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  result = (Ogre::Archive *) ((arg1)->archive);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Archive, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_filename_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  Ogre::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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","filename", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(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( "", "Ogre::String const &","filename", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","filename", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->filename = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_filename_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","filename", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  result = (Ogre::String *) & ((arg1)->filename);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_path_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  Ogre::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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","path", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(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( "", "Ogre::String const &","path", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","path", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->path = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_path_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","path", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  result = (Ogre::String *) & ((arg1)->path);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_basename_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  Ogre::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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","basename", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(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( "", "Ogre::String const &","basename", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","basename", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->basename = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_basename_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","basename", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  result = (Ogre::String *) & ((arg1)->basename);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_compressedSize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","compressedSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","compressedSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->compressedSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_compressedSize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","compressedSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  result =  ((arg1)->compressedSize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_uncompressedSize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","uncompressedSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","uncompressedSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->uncompressedSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileInfo_uncompressedSize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FileInfo *arg1 = (Ogre::FileInfo *) 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_Ogre__FileInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileInfo *","uncompressedSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileInfo * >(argp1);
  result =  ((arg1)->uncompressedSize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_FileInfo(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::FileInfo";
  Ogre::FileInfo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FileInfo *)new Ogre::FileInfo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FileInfo(Ogre::FileInfo *arg1) {
    delete arg1;
}

swig_class SwigClassArchive;

SWIGINTERN void
free_Ogre_Archive(Ogre::Archive *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Archive_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  result = (Ogre::String *) &((Ogre::Archive const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_isCaseSensitive(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","isCaseSensitive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  result = (bool)((Ogre::Archive const *)arg1)->isCaseSensitive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_load(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_isReadOnly(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","isReadOnly", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  result = (bool)((Ogre::Archive const *)arg1)->isReadOnly();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_open__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","open", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","open", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","open", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = ((Ogre::Archive const *)arg1)->open((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_open__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","open", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","open", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::Archive const *)arg1)->open((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Archive_open(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_Ogre__Archive, 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_Archive_open__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Archive_open__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Archive.open", 
    "    Ogre::DataStreamPtr Archive.open(Ogre::String const &filename, bool readOnly)\n"
    "    Ogre::DataStreamPtr Archive.open(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_create(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::Archive const *)arg1)->create((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_remove(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","remove", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","remove", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","remove", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ((Ogre::Archive const *)arg1)->remove((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_list__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","list", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","list", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->list(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_list__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","list", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->list(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_list__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  result = (arg1)->list();
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Archive_list(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_Ogre__Archive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Archive_list__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Archive_list__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Archive_list__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Archive.list", 
    "    Ogre::StringVectorPtr Archive.list(bool recursive, bool dirs)\n"
    "    Ogre::StringVectorPtr Archive.list(bool recursive)\n"
    "    Ogre::StringVectorPtr Archive.list()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_listFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","listFileInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","listFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->listFileInfo(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_listFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","listFileInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->listFileInfo(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_listFileInfo__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  result = (arg1)->listFileInfo();
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Archive_listFileInfo(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_Ogre__Archive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Archive_listFileInfo__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Archive_listFileInfo__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Archive_listFileInfo__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Archive.listFileInfo", 
    "    Ogre::FileInfoListPtr Archive.listFileInfo(bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr Archive.listFileInfo(bool recursive)\n"
    "    Ogre::FileInfoListPtr Archive.listFileInfo()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Archive.find

  call-seq:
    find(pattern, recursive=true, dirs=false) -> StringVectorPtr
    find(pattern, recursive=true) -> StringVectorPtr
    find(pattern) -> StringVectorPtr

Find an element in the class.
*/
SWIGINTERN VALUE
_wrap_Archive_find__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","find", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","find", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->find((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_find__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","find", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->find((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_find__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Archive_find(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_Ogre__Archive, 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_Archive_find__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Archive_find__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Archive_find__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Archive.find", 
    "    Ogre::StringVectorPtr Archive.find(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::StringVectorPtr Archive.find(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::StringVectorPtr Archive.find(Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_exists(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","exists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","exists", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exists", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->exists((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_getModifiedTime(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  time_t 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive *","getModifiedTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","getModifiedTime", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getModifiedTime", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getModifiedTime((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new time_t(static_cast< const time_t& >(result))), SWIGTYPE_p_time_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_findFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","findFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","findFileInfo", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = ((Ogre::Archive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_findFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","findFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = ((Ogre::Archive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_findFileInfo__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::Archive const *)arg1)->findFileInfo((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Archive_findFileInfo(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_Ogre__Archive, 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_Archive_findFileInfo__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Archive_findFileInfo__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Archive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Archive_findFileInfo__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Archive.findFileInfo", 
    "    Ogre::FileInfoListPtr Archive.findFileInfo(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr Archive.findFileInfo(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::FileInfoListPtr Archive.findFileInfo(Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Archive_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::Archive *arg1 = (Ogre::Archive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Archive const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Archive * >(argp1);
  result = (Ogre::String *) &((Ogre::Archive const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassArchiveFactory;

SWIGINTERN void
free_Ogre_ArchiveFactory(Ogre::ArchiveFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FastHash__SWIG_0(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int arg2 ;
  Ogre::uint32 arg3 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Ogre::uint32 result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","Ogre::FastHash", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Ogre::FastHash", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::FastHash", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  result = (Ogre::uint32)Ogre::FastHash((char const *)arg1,arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FastHash__SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::uint32 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","Ogre::FastHash", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Ogre::FastHash", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (Ogre::uint32)Ogre::FastHash((char const *)arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_FastHash(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 == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FastHash__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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) {
          return _wrap_FastHash__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "FastHash", 
    "    Ogre::uint32 FastHash(char const *data, int len, Ogre::uint32 hashSoFar)\n"
    "    Ogre::uint32 FastHash(char const *data, int len)\n");
  
  return Qnil;
}


swig_class SwigClassBox;

SWIGINTERN VALUE
_wrap_Box_left_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","left", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","left", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->left = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_left_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","left", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result =  ((arg1)->left);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_top_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","top", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","top", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->top = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_top_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","top", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result =  ((arg1)->top);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_right_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","right", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","right", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->right = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_right_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","right", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result =  ((arg1)->right);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_bottom_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","bottom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","bottom", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->bottom = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_bottom_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","bottom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result =  ((arg1)->bottom);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Box.front

  call-seq:
    front -> size_t

Return the first element in Box.
*/

/*
  Document-method: Ogre::Box.front=

  call-seq:
    front=(x) -> size_t

Return the first element in Box.
*/
SWIGINTERN VALUE
_wrap_Box_front_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","front", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","front", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->front = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_front_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","front", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result =  ((arg1)->front);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Box.back

  call-seq:
    back -> size_t

Return the last element in Box.
*/

/*
  Document-method: Ogre::Box.back=

  call-seq:
    back=(x) -> size_t

Return the last element in Box.
*/
SWIGINTERN VALUE
_wrap_Box_back_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","back", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","back", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->back = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_back_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box *","back", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result =  ((arg1)->back);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Box__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Box";
  Ogre::Box *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Box *)new Ogre::Box();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Box__SWIG_1(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Box";
  Ogre::Box *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  result = (Ogre::Box *)new Ogre::Box(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Box__SWIG_2(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Box";
  Ogre::Box *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 5, argv[4] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","Ogre::Box", 6, argv[5] ));
  } 
  arg6 = static_cast< size_t >(val6);
  result = (Ogre::Box *)new Ogre::Box(arg1,arg2,arg3,arg4,arg5,arg6);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Box(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_Box__SWIG_0(nargs, args, self);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_Box__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_Box__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Box.new", 
    "    Box.new()\n"
    "    Box.new(size_t l, size_t t, size_t r, size_t b)\n"
    "    Box.new(size_t l, size_t t, size_t ff, size_t r, size_t b, size_t bb)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_contains(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 0 ;
  Ogre::Box *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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box const *","contains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Box const &","contains", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Box const &","contains", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Box * >(argp2);
  result = (bool)((Ogre::Box const *)arg1)->contains((Ogre::Box const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result = ((Ogre::Box const *)arg1)->getWidth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result = ((Ogre::Box const *)arg1)->getHeight();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Box_getDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = (Ogre::Box *) 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_Ogre__Box, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box const *","getDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  result = ((Ogre::Box const *)arg1)->getDepth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Box(Ogre::Box *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_findCommandLineOpts(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  char **arg2 = (char **) 0 ;
  Ogre::UnaryOptionList *arg3 = 0 ;
  Ogre::BinaryOptionList *arg4 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::findCommandLineOpts", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char **","Ogre::findCommandLineOpts", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< char ** >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, 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,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UnaryOptionList &","Ogre::findCommandLineOpts", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UnaryOptionList &","Ogre::findCommandLineOpts", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::UnaryOptionList * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4, 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,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::BinaryOptionList &","Ogre::findCommandLineOpts", 4, argv[3] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::BinaryOptionList &","Ogre::findCommandLineOpts", 4, argv[3])); 
  }
  arg4 = reinterpret_cast< Ogre::BinaryOptionList * >(argp4);
  result = (int)Ogre::findCommandLineOpts(arg1,arg2,*arg3,*arg4);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRenderWindowDescription;

SWIGINTERN VALUE
_wrap_RenderWindowDescription_name_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 0 ;
  Ogre::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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(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( "", "Ogre::String const &","name", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","name", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_name_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(argp1);
  result = (Ogre::String *) & ((arg1)->name);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_width_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","width", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(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","width", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->width = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_width_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","width", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(argp1);
  result = (unsigned int) ((arg1)->width);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_height_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","height", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(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","height", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->height = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_height_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","height", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(argp1);
  result = (unsigned int) ((arg1)->height);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_useFullScreen_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","useFullScreen", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","useFullScreen", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->useFullScreen = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_useFullScreen_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","useFullScreen", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(argp1);
  result = (bool) ((arg1)->useFullScreen);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_miscParams_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 0 ;
  Ogre::NameValuePairList *arg2 = (Ogre::NameValuePairList *) 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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","miscParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,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, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::NameValuePairList *","miscParams", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::NameValuePairList * >(argp2);
  if (arg1) (arg1)->miscParams = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindowDescription_miscParams_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindowDescription *arg1 = (Ogre::RenderWindowDescription *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::NameValuePairList *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_Ogre__RenderWindowDescription, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescription *","miscParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindowDescription * >(argp1);
  result = (Ogre::NameValuePairList *)& ((arg1)->miscParams);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), 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, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderWindowDescription(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderWindowDescription";
  Ogre::RenderWindowDescription *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderWindowDescription *)new Ogre::RenderWindowDescription();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderWindowDescription(Ogre::RenderWindowDescription *arg1) {
    delete arg1;
}

swig_class SwigClassNameGenerator;

SWIGINTERN VALUE
_wrap_new_NameGenerator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::NameGenerator *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::NameGenerator";
  Ogre::NameGenerator *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__NameGenerator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NameGenerator const &","Ogre::NameGenerator", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::NameGenerator const &","Ogre::NameGenerator", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::NameGenerator * >(argp1);
  result = (Ogre::NameGenerator *)new Ogre::NameGenerator((Ogre::NameGenerator const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_NameGenerator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::NameGenerator";
  Ogre::NameGenerator *result = 0 ;
  
  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 &","Ogre::NameGenerator", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::NameGenerator", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::NameGenerator *)new Ogre::NameGenerator((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_NameGenerator(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__NameGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_NameGenerator__SWIG_0(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_new_NameGenerator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "NameGenerator.new", 
    "    NameGenerator.new(Ogre::NameGenerator const &rhs)\n"
    "    NameGenerator.new(Ogre::String const &prefix)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NameGenerator_generate(int argc, VALUE *argv, VALUE self) {
  Ogre::NameGenerator *arg1 = (Ogre::NameGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__NameGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NameGenerator *","generate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NameGenerator * >(argp1);
  result = (arg1)->generate();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NameGenerator_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::NameGenerator *arg1 = (Ogre::NameGenerator *) 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_Ogre__NameGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NameGenerator *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NameGenerator * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NameGenerator_setNext(int argc, VALUE *argv, VALUE self) {
  Ogre::NameGenerator *arg1 = (Ogre::NameGenerator *) 0 ;
  unsigned long long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__NameGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NameGenerator *","setNext", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NameGenerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long long","setNext", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned long long >(val2);
  (arg1)->setNext(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NameGenerator_getNext(int argc, VALUE *argv, VALUE self) {
  Ogre::NameGenerator *arg1 = (Ogre::NameGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__NameGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::NameGenerator const *","getNext", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::NameGenerator * >(argp1);
  result = (unsigned long long)((Ogre::NameGenerator const *)arg1)->getNext();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NameGenerator(Ogre::NameGenerator *arg1) {
    delete arg1;
}

swig_class SwigClassParameterDef;

SWIGINTERN VALUE
_wrap_ParameterDef_name_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ParameterDef *arg1 = (Ogre::ParameterDef *) 0 ;
  Ogre::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_Ogre__ParameterDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParameterDef *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParameterDef * >(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( "", "Ogre::String const &","name", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","name", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParameterDef_name_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ParameterDef *arg1 = (Ogre::ParameterDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParameterDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParameterDef *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParameterDef * >(argp1);
  result = (Ogre::String *) & ((arg1)->name);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParameterDef_description_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ParameterDef *arg1 = (Ogre::ParameterDef *) 0 ;
  Ogre::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_Ogre__ParameterDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParameterDef *","description", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParameterDef * >(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( "", "Ogre::String const &","description", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","description", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->description = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParameterDef_description_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ParameterDef *arg1 = (Ogre::ParameterDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParameterDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParameterDef *","description", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParameterDef * >(argp1);
  result = (Ogre::String *) & ((arg1)->description);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParameterDef_paramType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ParameterDef *arg1 = (Ogre::ParameterDef *) 0 ;
  Ogre::ParameterType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ParameterDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParameterDef *","paramType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParameterDef * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ParameterType","paramType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ParameterType >(val2);
  if (arg1) (arg1)->paramType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParameterDef_paramType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ParameterDef *arg1 = (Ogre::ParameterDef *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParameterType 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_Ogre__ParameterDef, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParameterDef *","paramType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParameterDef * >(argp1);
  result = (Ogre::ParameterType) ((arg1)->paramType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ParameterDef(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ParameterType arg3 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ParameterDef";
  Ogre::ParameterDef *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::ParameterDef", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ParameterDef", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ParameterDef", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ParameterDef", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ParameterType","Ogre::ParameterDef", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ParameterType >(val3);
  result = (Ogre::ParameterDef *)new Ogre::ParameterDef((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParameterDef(Ogre::ParameterDef *arg1) {
    delete arg1;
}

swig_class SwigClassParamCommand;

SWIGINTERN VALUE
_wrap_ParamCommand_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::ParamCommand *arg1 = (Ogre::ParamCommand *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__ParamCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParamCommand const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParamCommand * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::ParamCommand const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParamCommand_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::ParamCommand *arg1 = (Ogre::ParamCommand *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ParamCommand, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParamCommand *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParamCommand * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParamCommand(Ogre::ParamCommand *arg1) {
    delete arg1;
}

swig_class SwigClassParamDictionary;

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

SWIGINTERN VALUE
_wrap_new_ParamDictionary(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ParamDictionary";
  Ogre::ParamDictionary *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParamDictionary *)new Ogre::ParamDictionary();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParamDictionary_addParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParamDictionary *arg1 = (Ogre::ParamDictionary *) 0 ;
  Ogre::ParameterDef *arg2 = 0 ;
  Ogre::ParamCommand *arg3 = (Ogre::ParamCommand *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__ParamDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParamDictionary *","addParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParamDictionary * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ParameterDef,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParameterDef const &","addParameter", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ParameterDef const &","addParameter", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ParameterDef * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ParamCommand, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ParamCommand *","addParameter", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ParamCommand * >(argp3);
  (arg1)->addParameter((Ogre::ParameterDef const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParamDictionary_getParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::ParamDictionary *arg1 = (Ogre::ParamDictionary *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParameterList *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_Ogre__ParamDictionary, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParamDictionary const *","getParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParamDictionary * >(argp1);
  result = (Ogre::ParameterList *) &((Ogre::ParamDictionary const *)arg1)->getParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParamDictionary(Ogre::ParamDictionary *arg1) {
    delete arg1;
}

swig_class SwigClassStringInterface;

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

SWIGINTERN VALUE
_wrap_new_StringInterface(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::StringInterface";
  Ogre::StringInterface *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::StringInterface *)new Ogre::StringInterface();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StringInterface(Ogre::StringInterface *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_StringInterface_getParamDictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::StringInterface *arg1 = (Ogre::StringInterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringInterface *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StringInterface * >(argp1);
  result = (Ogre::ParamDictionary *)(arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringInterface_getParamDictionary__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::StringInterface *arg1 = (Ogre::StringInterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringInterface const *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StringInterface * >(argp1);
  result = (Ogre::ParamDictionary *)((Ogre::StringInterface const *)arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringInterface_getParamDictionary(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_Ogre__StringInterface, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringInterface_getParamDictionary__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StringInterface, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringInterface_getParamDictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.getParamDictionary", 
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringInterface_getParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::StringInterface *arg1 = (Ogre::StringInterface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParameterList *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_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringInterface const *","getParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StringInterface * >(argp1);
  result = (Ogre::ParameterList *) &((Ogre::StringInterface const *)arg1)->getParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringInterface_setParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::StringInterface *arg1 = (Ogre::StringInterface *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringInterface *","setParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StringInterface * >(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( "", "Ogre::String const &","setParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 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 &","setParameter", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  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_StringInterface_setParameterList(int argc, VALUE *argv, VALUE self) {
  Ogre::StringInterface *arg1 = (Ogre::StringInterface *) 0 ;
  Ogre::NameValuePairList *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_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringInterface *","setParameterList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StringInterface * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::NameValuePairList * >(argp2);
  (arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringInterface_getParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::StringInterface *arg1 = (Ogre::StringInterface *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringInterface const *","getParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StringInterface * >(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( "", "Ogre::String const &","getParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getParameter", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::StringInterface const *)arg1)->getParameter((Ogre::String const &)*arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringInterface_copyParametersTo(int argc, VALUE *argv, VALUE self) {
  Ogre::StringInterface *arg1 = (Ogre::StringInterface *) 0 ;
  Ogre::StringInterface *arg2 = (Ogre::StringInterface *) 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_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringInterface const *","copyParametersTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StringInterface * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringInterface *","copyParametersTo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::StringInterface * >(argp2);
  ((Ogre::StringInterface const *)arg1)->copyParametersTo(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringInterface_cleanupDictionary(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::StringInterface::cleanupDictionary();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassResourceSharedPtr;

SWIGINTERN VALUE
_wrap_new_ResourceSharedPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ResourceSharedPtr";
  Ogre::SharedPtr< Ogre::Resource > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SharedPtr< Ogre::Resource > *)new Ogre::SharedPtr< Ogre::Resource >();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ResourceSharedPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ResourceSharedPtr";
  Ogre::SharedPtr< Ogre::Resource > *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const &","Ogre::SharedPtr<(Ogre::Resource)>", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SharedPtr< Ogre::Resource > const &","Ogre::SharedPtr<(Ogre::Resource)>", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::SharedPtr< Ogre::Resource > *)new Ogre::SharedPtr< Ogre::Resource >((Ogre::SharedPtr< Ogre::Resource > const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ResourceSharedPtr(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_ResourceSharedPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ResourceSharedPtr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ResourceSharedPtr.new", 
    "    ResourceSharedPtr.new()\n"
    "    ResourceSharedPtr.new(Ogre::SharedPtr< Ogre::Resource > const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_SharedPtr_Sl_Ogre_Resource_Sg_(Ogre::SharedPtr< Ogre::Resource > *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ResourceSharedPtr___ref__(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::Resource *) &((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->operator *();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr___deref__(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","operator ->", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::Resource *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->operator ->();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::Resource *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->get();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_bind__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 0 ;
  Ogre::SharedPtrFreeMethod arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","bind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","bind", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SharedPtrFreeMethod","bind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SharedPtrFreeMethod >(val3);
  (arg1)->bind(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_bind__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","bind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","bind", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->bind(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceSharedPtr_bind(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_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Resource, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ResourceSharedPtr_bind__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Resource, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceSharedPtr_bind__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceSharedPtr.bind", 
    "    void ResourceSharedPtr.bind(Ogre::Resource *rep, Ogre::SharedPtrFreeMethod inFreeMethod)\n"
    "    void ResourceSharedPtr.bind(Ogre::Resource *rep)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_unique(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","unique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->unique();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_useCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","useCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (unsigned int)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->useCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_useCountPointer(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","useCountPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (unsigned int *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->useCountPointer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getPointer(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::Resource *)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->getPointer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_freeMethod(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SharedPtrFreeMethod 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","freeMethod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::SharedPtrFreeMethod)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->freeMethod();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_isNull(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","isNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)((Ogre::SharedPtr< Ogre::Resource > const *)arg1)->isNull();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_setNull(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","setNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (arg1)->setNull();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","prepare", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->prepare(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceSharedPtr_prepare(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_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceSharedPtr_prepare__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceSharedPtr_prepare__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.prepare", 
    "    void Resource.prepare(bool backgroundThread)\n"
    "    void Resource.prepare()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","load", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->load(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceSharedPtr_load(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_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceSharedPtr_load__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceSharedPtr_load__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.load", 
    "    void Resource.load(bool backgroundThread)\n"
    "    void Resource.load()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_reload(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","reload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->reload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_isReloadable(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","isReloadable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)(*arg1)->isReloadable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_isManuallyLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","isManuallyLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)(*arg1)->isManuallyLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (*arg1)->getSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_touch(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","touch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->touch();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceHandle 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::ResourceHandle)(*arg1)->getHandle();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_isPrepared(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","isPrepared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)(*arg1)->isPrepared();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)(*arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_isLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","isLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)(*arg1)->isLoading();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getLoadingState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource::LoadingState 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getLoadingState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::Resource::LoadingState)(*arg1)->getLoadingState();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_isBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","isBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (bool)(*arg1)->isBackgroundLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_setBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","setBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBackgroundLoaded", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setBackgroundLoaded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_escalateLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","escalateLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->escalateLoading();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (*arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (*arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_changeGroupOwnership(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","changeGroupOwnership", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(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( "", "Ogre::String const &","changeGroupOwnership", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","changeGroupOwnership", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getCreator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceManager *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","getCreator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::ResourceManager *)(*arg1)->getCreator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getOrigin();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr__notifyOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","_notifyOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(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( "", "Ogre::String const &","_notifyOrigin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyOrigin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->_notifyOrigin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getStateCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getStateCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (*arg1)->getStateCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr__dirtyState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","_dirtyState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->_dirtyState();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr__fireLoadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","_fireLoadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_fireLoadingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->_fireLoadingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr__firePreparingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","_firePreparingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_firePreparingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->_firePreparingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr__fireUnloadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","_fireUnloadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->_fireUnloadingComplete();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getParamDictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getParamDictionary__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceSharedPtr_getParamDictionary(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_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceSharedPtr_getParamDictionary__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceSharedPtr_getParamDictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.getParamDictionary", 
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParameterList *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  result = (Ogre::ParameterList *) &(*arg1)->getParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_setParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","setParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(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( "", "Ogre::String const &","setParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 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 &","setParameter", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)(*arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  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_ResourceSharedPtr_setParameterList(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::NameValuePairList *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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","setParameterList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::NameValuePairList * >(argp2);
  (*arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_getParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","getParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(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( "", "Ogre::String const &","getParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getParameter", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (*arg1)->getParameter((Ogre::String const &)*arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_copyParametersTo(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 0 ;
  Ogre::StringInterface *arg2 = (Ogre::StringInterface *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > const *","copyParametersTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringInterface *","copyParametersTo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::StringInterface * >(argp2);
  (*arg1)->copyParametersTo(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceSharedPtr_cleanupDictionary(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Resource > *arg1 = (Ogre::SharedPtr< Ogre::Resource > *) 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_Ogre__SharedPtrT_Ogre__Resource_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Resource > *","cleanupDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Resource > * >(argp1);
  (*arg1)->cleanupDictionary();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassResource;

SWIGINTERN void
free_Ogre_Resource(Ogre::Resource *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Resource_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","prepare", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->prepare(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Resource_prepare(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_Ogre__Resource, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Resource_prepare__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Resource, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Resource_prepare__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.prepare", 
    "    void Resource.prepare(bool backgroundThread)\n"
    "    void Resource.prepare()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","load", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->load(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Resource_load(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_Ogre__Resource, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Resource_load__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Resource, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Resource_load__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.load", 
    "    void Resource.load(bool backgroundThread)\n"
    "    void Resource.load()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_reload(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","reload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->reload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_isReloadable(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","isReloadable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (bool)((Ogre::Resource const *)arg1)->isReloadable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_isManuallyLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","isManuallyLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (bool)((Ogre::Resource const *)arg1)->isManuallyLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = ((Ogre::Resource const *)arg1)->getSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_touch(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","touch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->touch();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (Ogre::String *) &((Ogre::Resource const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceHandle 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","getHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (Ogre::ResourceHandle)((Ogre::Resource const *)arg1)->getHandle();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_isPrepared(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","isPrepared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (bool)((Ogre::Resource const *)arg1)->isPrepared();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (bool)((Ogre::Resource const *)arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_isLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","isLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (bool)((Ogre::Resource const *)arg1)->isLoading();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getLoadingState(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource::LoadingState 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","getLoadingState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (Ogre::Resource::LoadingState)((Ogre::Resource const *)arg1)->getLoadingState();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_isBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","isBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (bool)((Ogre::Resource const *)arg1)->isBackgroundLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_setBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","setBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBackgroundLoaded", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBackgroundLoaded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_escalateLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","escalateLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->escalateLoading();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (Ogre::String *) &((Ogre::Resource const *)arg1)->getGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_changeGroupOwnership(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  Ogre::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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","changeGroupOwnership", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(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( "", "Ogre::String const &","changeGroupOwnership", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","changeGroupOwnership", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getCreator(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceManager *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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","getCreator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (Ogre::ResourceManager *)(arg1)->getCreator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = (Ogre::String *) &((Ogre::Resource const *)arg1)->getOrigin();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource__notifyOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  Ogre::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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","_notifyOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(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( "", "Ogre::String const &","_notifyOrigin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyOrigin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->_notifyOrigin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource_getStateCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource const *","getStateCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  result = ((Ogre::Resource const *)arg1)->getStateCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource__dirtyState(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","_dirtyState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->_dirtyState();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource__fireLoadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","_fireLoadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_fireLoadingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_fireLoadingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource__firePreparingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","_firePreparingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_firePreparingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_firePreparingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Resource__fireUnloadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::Resource *arg1 = (Ogre::Resource *) 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_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Resource *","_fireUnloadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Resource * >(argp1);
  (arg1)->_fireUnloadingComplete();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassManualResourceLoader;

SWIGINTERN void
free_Ogre_ManualResourceLoader(Ogre::ManualResourceLoader *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ManualResourceLoader_prepareResource(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualResourceLoader *arg1 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","prepareResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","prepareResource", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->prepareResource(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualResourceLoader_loadResource(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualResourceLoader *arg1 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","loadResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","loadResource", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->loadResource(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassResourceGroupListener;

SWIGINTERN void
free_Ogre_ResourceGroupListener(Ogre::ResourceGroupListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceGroupScriptingStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceGroupScriptingStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","resourceGroupScriptingStarted", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceGroupScriptingStarted", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","resourceGroupScriptingStarted", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->resourceGroupScriptingStarted((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_scriptParseStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","scriptParseStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","scriptParseStarted", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","scriptParseStarted", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "bool &","scriptParseStarted", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","scriptParseStarted", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< bool * >(argp3);
  (arg1)->scriptParseStarted((Ogre::String const &)*arg2,*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_scriptParseEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","scriptParseEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","scriptParseEnded", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","scriptParseEnded", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","scriptParseEnded", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->scriptParseEnded((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceGroupScriptingEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceGroupScriptingEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","resourceGroupScriptingEnded", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceGroupScriptingEnded", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->resourceGroupScriptingEnded((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceGroupPrepareStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceGroupPrepareStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","resourceGroupPrepareStarted", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceGroupPrepareStarted", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","resourceGroupPrepareStarted", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->resourceGroupPrepareStarted((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourcePrepareStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::ResourcePtr *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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourcePrepareStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","resourcePrepareStarted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","resourcePrepareStarted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ResourcePtr * >(argp2);
  (arg1)->resourcePrepareStarted((Ogre::ResourcePtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourcePrepareEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourcePrepareEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp1);
  (arg1)->resourcePrepareEnded();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_worldGeometryPrepareStageStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","worldGeometryPrepareStageStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","worldGeometryPrepareStageStarted", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","worldGeometryPrepareStageStarted", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->worldGeometryPrepareStageStarted((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_worldGeometryPrepareStageEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","worldGeometryPrepareStageEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp1);
  (arg1)->worldGeometryPrepareStageEnded();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceGroupPrepareEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceGroupPrepareEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","resourceGroupPrepareEnded", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceGroupPrepareEnded", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->resourceGroupPrepareEnded((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceGroupLoadStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceGroupLoadStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","resourceGroupLoadStarted", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceGroupLoadStarted", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","resourceGroupLoadStarted", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->resourceGroupLoadStarted((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceLoadStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::ResourcePtr *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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceLoadStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","resourceLoadStarted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","resourceLoadStarted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ResourcePtr * >(argp2);
  (arg1)->resourceLoadStarted((Ogre::ResourcePtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceLoadEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceLoadEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp1);
  (arg1)->resourceLoadEnded();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_worldGeometryStageStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","worldGeometryStageStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","worldGeometryStageStarted", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","worldGeometryStageStarted", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->worldGeometryStageStarted((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_worldGeometryStageEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","worldGeometryStageEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp1);
  (arg1)->worldGeometryStageEnded();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupListener_resourceGroupLoadEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupListener *arg1 = (Ogre::ResourceGroupListener *) 0 ;
  Ogre::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_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","resourceGroupLoadEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupListener * >(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( "", "Ogre::String const &","resourceGroupLoadEnded", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceGroupLoadEnded", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->resourceGroupLoadEnded((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassResourceLoadingListener;

SWIGINTERN void
free_Ogre_ResourceLoadingListener(Ogre::ResourceLoadingListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ResourceLoadingListener_resourceLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceLoadingListener *arg1 = (Ogre::ResourceLoadingListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Resource *arg4 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ResourceLoadingListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceLoadingListener *","resourceLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceLoadingListener * >(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( "", "Ogre::String const &","resourceLoading", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceLoading", 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 &","resourceLoading", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceLoading", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Resource *","resourceLoading", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Resource * >(argp4);
  result = (arg1)->resourceLoading((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_ResourceLoadingListener_resourceStreamOpened(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceLoadingListener *arg1 = (Ogre::ResourceLoadingListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Resource *arg4 = (Ogre::Resource *) 0 ;
  Ogre::DataStreamPtr *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__ResourceLoadingListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceLoadingListener *","resourceStreamOpened", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceLoadingListener * >(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( "", "Ogre::String const &","resourceStreamOpened", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceStreamOpened", 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 &","resourceStreamOpened", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceStreamOpened", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Resource *","resourceStreamOpened", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Resource * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","resourceStreamOpened", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","resourceStreamOpened", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::DataStreamPtr * >(argp5);
  (arg1)->resourceStreamOpened((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,*arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceLoadingListener_resourceCollision(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceLoadingListener *arg1 = (Ogre::ResourceLoadingListener *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 0 ;
  Ogre::ResourceManager *arg3 = (Ogre::ResourceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__ResourceLoadingListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceLoadingListener *","resourceCollision", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceLoadingListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","resourceCollision", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","resourceCollision", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ResourceManager * >(argp3);
  result = (bool)(arg1)->resourceCollision(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassResourceGroupManager;

SWIGINTERN VALUE
_wrap_ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::ResourceGroupManager::DEFAULT_RESOURCE_GROUP_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_size_t(static_cast< size_t >(Ogre::ResourceGroupManager::RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS));
  return _val;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS_set(VALUE self, VALUE _val) {
  {
    size_t val;
    int res = SWIG_AsVal_size_t(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::ResourceGroupManager::RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS""' of type '""size_t""'");
    }
    Ogre::ResourceGroupManager::RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS = static_cast< size_t >(val);
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ResourceGroupManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ResourceGroupManager";
  Ogre::ResourceGroupManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ResourceGroupManager *)new Ogre::ResourceGroupManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ResourceGroupManager(Ogre::ResourceGroupManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ResourceGroupManager_createResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","createResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","createResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","createResourceGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->createResourceGroup((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_createResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","createResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","createResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->createResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_createResourceGroup(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_createResourceGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceGroupManager_createResourceGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.createResourceGroup", 
    "    void ResourceGroupManager.createResourceGroup(Ogre::String const &name, bool const inGlobalPool)\n"
    "    void ResourceGroupManager.createResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_initialiseResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","initialiseResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","initialiseResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","initialiseResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->initialiseResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_initialiseAllResourceGroups(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","initialiseAllResourceGroups", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  (arg1)->initialiseAllResourceGroups();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_prepareResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","prepareResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","prepareResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepareResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","prepareResourceGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","prepareResourceGroup", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->prepareResourceGroup((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_prepareResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","prepareResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","prepareResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepareResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","prepareResourceGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->prepareResourceGroup((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_prepareResourceGroup__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","prepareResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","prepareResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepareResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->prepareResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_prepareResourceGroup(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_prepareResourceGroup__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceGroupManager_prepareResourceGroup__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceGroupManager_prepareResourceGroup__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.prepareResourceGroup", 
    "    void ResourceGroupManager.prepareResourceGroup(Ogre::String const &name, bool prepareMainResources, bool prepareWorldGeom)\n"
    "    void ResourceGroupManager.prepareResourceGroup(Ogre::String const &name, bool prepareMainResources)\n"
    "    void ResourceGroupManager.prepareResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_loadResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","loadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","loadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","loadResourceGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","loadResourceGroup", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->loadResourceGroup((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_loadResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","loadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","loadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","loadResourceGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->loadResourceGroup((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_loadResourceGroup__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","loadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","loadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->loadResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_loadResourceGroup(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_loadResourceGroup__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceGroupManager_loadResourceGroup__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceGroupManager_loadResourceGroup__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.loadResourceGroup", 
    "    void ResourceGroupManager.loadResourceGroup(Ogre::String const &name, bool loadMainResources, bool loadWorldGeom)\n"
    "    void ResourceGroupManager.loadResourceGroup(Ogre::String const &name, bool loadMainResources)\n"
    "    void ResourceGroupManager.loadResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_unloadResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","unloadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","unloadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unloadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","unloadResourceGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->unloadResourceGroup((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_unloadResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","unloadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","unloadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unloadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unloadResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_unloadResourceGroup(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_unloadResourceGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceGroupManager_unloadResourceGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.unloadResourceGroup", 
    "    void ResourceGroupManager.unloadResourceGroup(Ogre::String const &name, bool reloadableOnly)\n"
    "    void ResourceGroupManager.unloadResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_unloadUnreferencedResourcesInGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","unloadUnreferencedResourcesInGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","unloadUnreferencedResourcesInGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unloadUnreferencedResourcesInGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","unloadUnreferencedResourcesInGroup", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->unloadUnreferencedResourcesInGroup((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_unloadUnreferencedResourcesInGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","unloadUnreferencedResourcesInGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","unloadUnreferencedResourcesInGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unloadUnreferencedResourcesInGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unloadUnreferencedResourcesInGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_unloadUnreferencedResourcesInGroup(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_unloadUnreferencedResourcesInGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceGroupManager_unloadUnreferencedResourcesInGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.unloadUnreferencedResourcesInGroup", 
    "    void ResourceGroupManager.unloadUnreferencedResourcesInGroup(Ogre::String const &name, bool reloadableOnly)\n"
    "    void ResourceGroupManager.unloadUnreferencedResourcesInGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_clearResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","clearResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","clearResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clearResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->clearResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_destroyResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","destroyResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","destroyResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_isResourceGroupInitialised(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","isResourceGroupInitialised", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","isResourceGroupInitialised", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isResourceGroupInitialised", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isResourceGroupInitialised((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_isResourceGroupLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","isResourceGroupLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","isResourceGroupLoaded", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isResourceGroupLoaded", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isResourceGroupLoaded((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_resourceGroupExists(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","resourceGroupExists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","resourceGroupExists", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceGroupExists", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->resourceGroupExists((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_addResourceLocation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","addResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","addResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 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 &","addResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","addResourceLocation", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","addResourceLocation", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_addResourceLocation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","addResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","addResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 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 &","addResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","addResourceLocation", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_addResourceLocation__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","addResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","addResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 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 &","addResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_addResourceLocation(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_addResourceLocation__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceGroupManager_addResourceLocation__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ResourceGroupManager_addResourceLocation__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ResourceGroupManager.addResourceLocation", 
    "    void ResourceGroupManager.addResourceLocation(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &resGroup, bool recursive)\n"
    "    void ResourceGroupManager.addResourceLocation(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &resGroup)\n"
    "    void ResourceGroupManager.addResourceLocation(Ogre::String const &name, Ogre::String const &locType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_removeResourceLocation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","removeResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","removeResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeResourceLocation", 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 &","removeResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->removeResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_removeResourceLocation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","removeResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","removeResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeResourceLocation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeResourceLocation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_removeResourceLocation(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_removeResourceLocation__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_ResourceGroupManager_removeResourceLocation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.removeResourceLocation", 
    "    void ResourceGroupManager.removeResourceLocation(Ogre::String const &name, Ogre::String const &resGroup)\n"
    "    void ResourceGroupManager.removeResourceLocation(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_resourceLocationExists__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","resourceLocationExists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","resourceLocationExists", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceLocationExists", 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 &","resourceLocationExists", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceLocationExists", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->resourceLocationExists((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  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_ResourceGroupManager_resourceLocationExists__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","resourceLocationExists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","resourceLocationExists", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceLocationExists", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->resourceLocationExists((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_resourceLocationExists(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_resourceLocationExists__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_ResourceGroupManager_resourceLocationExists__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.resourceLocationExists", 
    "    bool ResourceGroupManager.resourceLocationExists(Ogre::String const &name, Ogre::String const &resGroup)\n"
    "    bool ResourceGroupManager.resourceLocationExists(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_declareResource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::NameValuePairList *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","declareResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","declareResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 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 &","declareResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","declareResource", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5, 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,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const &","declareResource", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::NameValuePairList const &","declareResource", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::NameValuePairList * >(argp5);
  (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,(Ogre::NameValuePairList const &)*arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_declareResource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","declareResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","declareResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 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 &","declareResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","declareResource", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_declareResource__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","declareResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","declareResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 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 &","declareResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_declareResource__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","declareResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","declareResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 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 &","declareResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","declareResource", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","declareResource", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, 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,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const &","declareResource", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::NameValuePairList const &","declareResource", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::NameValuePairList const &)*arg6);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_declareResource__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","declareResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","declareResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 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 &","declareResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","declareResource", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","declareResource", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","declareResource", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  (arg1)->declareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_declareResource(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_declareResource__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceGroupManager_declareResource__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, 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, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceGroupManager_declareResource__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceGroupManager_declareResource__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ResourceGroupManager_declareResource__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ResourceGroupManager.declareResource", 
    "    void ResourceGroupManager.declareResource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName, Ogre::NameValuePairList const &loadParameters)\n"
    "    void ResourceGroupManager.declareResource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName)\n"
    "    void ResourceGroupManager.declareResource(Ogre::String const &name, Ogre::String const &resourceType)\n"
    "    void ResourceGroupManager.declareResource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const &loadParameters)\n"
    "    void ResourceGroupManager.declareResource(Ogre::String const &name, Ogre::String const &resourceType, Ogre::String const &groupName, Ogre::ManualResourceLoader *loader)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_undeclareResource(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","undeclareResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","undeclareResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","undeclareResource", 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 &","undeclareResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","undeclareResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->undeclareResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_openResource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::Resource *arg5 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > result;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","openResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","openResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResource", 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 &","openResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openResource", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Resource *","openResource", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Resource * >(argp5);
  result = (arg1)->openResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_ResourceGroupManager_openResource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","openResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","openResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResource", 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 &","openResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","openResource", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->openResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_ResourceGroupManager_openResource__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","openResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","openResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResource", 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 &","openResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->openResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_ResourceGroupManager_openResource__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","openResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","openResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->openResource((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_openResource(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_openResource__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_ResourceGroupManager_openResource__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceGroupManager_openResource__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Resource, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceGroupManager_openResource__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ResourceGroupManager.openResource", 
    "    Ogre::DataStreamPtr ResourceGroupManager.openResource(Ogre::String const &resourceName, Ogre::String const &groupName, bool searchGroupsIfNotFound, Ogre::Resource *resourceBeingLoaded)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.openResource(Ogre::String const &resourceName, Ogre::String const &groupName, bool searchGroupsIfNotFound)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.openResource(Ogre::String const &resourceName, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.openResource(Ogre::String const &resourceName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_openResources__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::DataStreamPtr,Ogre::STLAllocator< Ogre::DataStreamPtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","openResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","openResources", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResources", 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 &","openResources", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResources", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->openResources((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamListPtr(static_cast< const Ogre::DataStreamListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ResourceGroupManager_openResources__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::DataStreamPtr,Ogre::STLAllocator< Ogre::DataStreamPtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","openResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","openResources", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openResources", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->openResources((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamListPtr(static_cast< const Ogre::DataStreamListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__DataStreamPtr_Ogre__STLAllocatorT_Ogre__DataStreamPtr_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_openResources(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_openResources__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_ResourceGroupManager_openResources__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.openResources", 
    "    Ogre::DataStreamListPtr ResourceGroupManager.openResources(Ogre::String const &pattern, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamListPtr ResourceGroupManager.openResources(Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_listResourceNames__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","listResourceNames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","listResourceNames", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","listResourceNames", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","listResourceNames", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->listResourceNames((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_listResourceNames__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","listResourceNames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","listResourceNames", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","listResourceNames", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->listResourceNames((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_listResourceNames(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_listResourceNames__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceGroupManager_listResourceNames__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.listResourceNames", 
    "    Ogre::StringVectorPtr ResourceGroupManager.listResourceNames(Ogre::String const &groupName, bool dirs)\n"
    "    Ogre::StringVectorPtr ResourceGroupManager.listResourceNames(Ogre::String const &groupName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_listResourceFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","listResourceFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","listResourceFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","listResourceFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","listResourceFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->listResourceFileInfo((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_listResourceFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","listResourceFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","listResourceFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","listResourceFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->listResourceFileInfo((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_listResourceFileInfo(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_listResourceFileInfo__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceGroupManager_listResourceFileInfo__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceGroupManager.listResourceFileInfo", 
    "    Ogre::FileInfoListPtr ResourceGroupManager.listResourceFileInfo(Ogre::String const &groupName, bool dirs)\n"
    "    Ogre::FileInfoListPtr ResourceGroupManager.listResourceFileInfo(Ogre::String const &groupName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_findResourceNames__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","findResourceNames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","findResourceNames", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceNames", 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 &","findResourceNames", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceNames", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","findResourceNames", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->findResourceNames((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ResourceGroupManager_findResourceNames__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","findResourceNames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","findResourceNames", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceNames", 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 &","findResourceNames", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceNames", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->findResourceNames((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ResourceGroupManager_findResourceNames(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_findResourceNames__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceGroupManager_findResourceNames__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.findResourceNames", 
    "    Ogre::StringVectorPtr ResourceGroupManager.findResourceNames(Ogre::String const &groupName, Ogre::String const &pattern, bool dirs)\n"
    "    Ogre::StringVectorPtr ResourceGroupManager.findResourceNames(Ogre::String const &groupName, Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_resourceExistsInAnyGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","resourceExistsInAnyGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","resourceExistsInAnyGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceExistsInAnyGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->resourceExistsInAnyGroup((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_findGroupContainingResource(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::String *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","findGroupContainingResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","findGroupContainingResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findGroupContainingResource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::String *) &(arg1)->findGroupContainingResource((Ogre::String const &)*arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_findResourceFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","findResourceFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","findResourceFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceFileInfo", 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 &","findResourceFileInfo", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceFileInfo", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","findResourceFileInfo", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->findResourceFileInfo((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ResourceGroupManager_findResourceFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","findResourceFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","findResourceFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceFileInfo", 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 &","findResourceFileInfo", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceFileInfo", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->findResourceFileInfo((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ResourceGroupManager_findResourceFileInfo(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_findResourceFileInfo__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceGroupManager_findResourceFileInfo__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.findResourceFileInfo", 
    "    Ogre::FileInfoListPtr ResourceGroupManager.findResourceFileInfo(Ogre::String const &group, Ogre::String const &pattern, bool dirs)\n"
    "    Ogre::FileInfoListPtr ResourceGroupManager.findResourceFileInfo(Ogre::String const &group, Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_listResourceLocations(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","listResourceLocations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","listResourceLocations", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","listResourceLocations", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->listResourceLocations((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_findResourceLocation(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","findResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","findResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceLocation", 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 &","findResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->findResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ResourceGroupManager_createResource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::String *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > result;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","createResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","createResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 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 &","createResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createResource", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","createResource", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  result = (arg1)->createResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_createResource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","createResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","createResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 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 &","createResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createResource", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->createResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_ResourceGroupManager_createResource__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","createResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","createResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 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 &","createResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->createResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_ResourceGroupManager_createResource__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","createResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","createResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createResource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->createResource((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_createResource(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_createResource__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_ResourceGroupManager_createResource__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceGroupManager_createResource__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceGroupManager_createResource__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ResourceGroupManager.createResource", 
    "    Ogre::DataStreamPtr ResourceGroupManager.createResource(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite, Ogre::String const &locationPattern)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.createResource(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.createResource(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr ResourceGroupManager.createResource(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_deleteResource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","deleteResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","deleteResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteResource", 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 &","deleteResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","deleteResource", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteResource", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->deleteResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_deleteResource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","deleteResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","deleteResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteResource", 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 &","deleteResource", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteResource", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->deleteResource((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_deleteResource__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","deleteResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","deleteResource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteResource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->deleteResource((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_deleteResource(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_deleteResource__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_ResourceGroupManager_deleteResource__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceGroupManager_deleteResource__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.deleteResource", 
    "    void ResourceGroupManager.deleteResource(Ogre::String const &filename, Ogre::String const &groupName, Ogre::String const &locationPattern)\n"
    "    void ResourceGroupManager.deleteResource(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    void ResourceGroupManager.deleteResource(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_deleteMatchingResources__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","deleteMatchingResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","deleteMatchingResources", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteMatchingResources", 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 &","deleteMatchingResources", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteMatchingResources", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","deleteMatchingResources", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteMatchingResources", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->deleteMatchingResources((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_deleteMatchingResources__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","deleteMatchingResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","deleteMatchingResources", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteMatchingResources", 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 &","deleteMatchingResources", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteMatchingResources", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->deleteMatchingResources((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_deleteMatchingResources__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","deleteMatchingResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","deleteMatchingResources", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","deleteMatchingResources", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->deleteMatchingResources((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceGroupManager_deleteMatchingResources(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_Ogre__ResourceGroupManager, 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_ResourceGroupManager_deleteMatchingResources__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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_ResourceGroupManager_deleteMatchingResources__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceGroupManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceGroupManager_deleteMatchingResources__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceGroupManager.deleteMatchingResources", 
    "    void ResourceGroupManager.deleteMatchingResources(Ogre::String const &filePattern, Ogre::String const &groupName, Ogre::String const &locationPattern)\n"
    "    void ResourceGroupManager.deleteMatchingResources(Ogre::String const &filePattern, Ogre::String const &groupName)\n"
    "    void ResourceGroupManager.deleteMatchingResources(Ogre::String const &filePattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_addResourceGroupListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ResourceGroupListener *arg2 = (Ogre::ResourceGroupListener *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","addResourceGroupListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","addResourceGroupListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp2);
  (arg1)->addResourceGroupListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_removeResourceGroupListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ResourceGroupListener *arg2 = (Ogre::ResourceGroupListener *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","removeResourceGroupListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ResourceGroupListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourceGroupListener *","removeResourceGroupListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ResourceGroupListener * >(argp2);
  (arg1)->removeResourceGroupListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_setWorldResourceGroupName(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","setWorldResourceGroupName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","setWorldResourceGroupName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setWorldResourceGroupName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setWorldResourceGroupName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getWorldResourceGroupName(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager const *","getWorldResourceGroupName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  result = (Ogre::String *) &((Ogre::ResourceGroupManager const *)arg1)->getWorldResourceGroupName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_linkWorldGeometryToResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::SceneManager *arg4 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","linkWorldGeometryToResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","linkWorldGeometryToResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","linkWorldGeometryToResourceGroup", 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 &","linkWorldGeometryToResourceGroup", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","linkWorldGeometryToResourceGroup", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::SceneManager *","linkWorldGeometryToResourceGroup", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::SceneManager * >(argp4);
  (arg1)->linkWorldGeometryToResourceGroup((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_unlinkWorldGeometryFromResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","unlinkWorldGeometryFromResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","unlinkWorldGeometryFromResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unlinkWorldGeometryFromResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unlinkWorldGeometryFromResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_isResourceGroupInGlobalPool(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","isResourceGroupInGlobalPool", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","isResourceGroupInGlobalPool", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isResourceGroupInGlobalPool", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isResourceGroupInGlobalPool((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_shutdownAll(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","shutdownAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  (arg1)->shutdownAll();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__registerResourceManager(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceManager *arg3 = (Ogre::ResourceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_registerResourceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","_registerResourceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_registerResourceManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","_registerResourceManager", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ResourceManager * >(argp3);
  (arg1)->_registerResourceManager((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__unregisterResourceManager(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_unregisterResourceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","_unregisterResourceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_unregisterResourceManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->_unregisterResourceManager((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getResourceManagerIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ResourceGroupManager::ResourceManagerIterator > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","getResourceManagerIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  result = (arg1)->getResourceManagerIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ResourceGroupManager::ResourceManagerIterator(static_cast< const Ogre::ResourceGroupManager::ResourceManagerIterator& >(result))), SWIGTYPE_p_Ogre__ResourceGroupManager__ResourceManagerIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__registerScriptLoader(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ScriptLoader *arg2 = (Ogre::ScriptLoader *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_registerScriptLoader", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptLoader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptLoader *","_registerScriptLoader", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptLoader * >(argp2);
  (arg1)->_registerScriptLoader(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__unregisterScriptLoader(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ScriptLoader *arg2 = (Ogre::ScriptLoader *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_unregisterScriptLoader", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptLoader, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptLoader *","_unregisterScriptLoader", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptLoader * >(argp2);
  (arg1)->_unregisterScriptLoader(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__findScriptLoader(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ScriptLoader *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_findScriptLoader", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","_findScriptLoader", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_findScriptLoader", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ScriptLoader *)(arg1)->_findScriptLoader((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptLoader, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__getResourceManager(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ResourceManager *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_getResourceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","_getResourceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getResourceManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ResourceManager *)(arg1)->_getResourceManager((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__notifyResourceCreated(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ResourcePtr *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_notifyResourceCreated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourcePtr &","_notifyResourceCreated", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr &","_notifyResourceCreated", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ResourcePtr * >(argp2);
  (arg1)->_notifyResourceCreated(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__notifyResourceRemoved(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ResourcePtr *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_notifyResourceRemoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourcePtr &","_notifyResourceRemoved", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr &","_notifyResourceRemoved", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ResourcePtr * >(argp2);
  (arg1)->_notifyResourceRemoved(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__notifyResourceGroupChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Resource *arg3 = (Ogre::Resource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_notifyResourceGroupChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","_notifyResourceGroupChanged", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyResourceGroupChanged", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Resource *","_notifyResourceGroupChanged", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Resource * >(argp3);
  (arg1)->_notifyResourceGroupChanged((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__notifyAllResourcesRemoved(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ResourceManager *arg2 = (Ogre::ResourceManager *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_notifyAllResourcesRemoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","_notifyAllResourcesRemoved", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ResourceManager * >(argp2);
  (arg1)->_notifyAllResourcesRemoved(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__notifyWorldGeometryStageStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_notifyWorldGeometryStageStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","_notifyWorldGeometryStageStarted", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyWorldGeometryStageStarted", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->_notifyWorldGeometryStageStarted((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager__notifyWorldGeometryStageEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","_notifyWorldGeometryStageEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  (arg1)->_notifyWorldGeometryStageEnded();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getResourceGroups(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","getResourceGroups", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  result = (arg1)->getResourceGroups();
  vresult = SWIG_NewPointerObj((new Ogre::StringVector(static_cast< const Ogre::StringVector& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getResourceDeclarationList(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::list< ResourceDeclaration,Ogre::STLAllocator< ResourceDeclaration,Ogre::GeneralAllocPolicy > >::type > 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","getResourceDeclarationList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","getResourceDeclarationList", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getResourceDeclarationList", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getResourceDeclarationList((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceGroupManager::ResourceDeclarationList(static_cast< const Ogre::ResourceGroupManager::ResourceDeclarationList& >(result))), SWIGTYPE_p_Ogre__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getResourceLocationList(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ResourceGroupManager::LocationList *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","getResourceLocationList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(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( "", "Ogre::String const &","getResourceLocationList", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getResourceLocationList", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ResourceGroupManager::LocationList *) &(arg1)->getResourceLocationList((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_setLoadingListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  Ogre::ResourceLoadingListener *arg2 = (Ogre::ResourceLoadingListener *) 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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","setLoadingListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ResourceLoadingListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourceLoadingListener *","setLoadingListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ResourceLoadingListener * >(argp2);
  (arg1)->setLoadingListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getLoadingListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *arg1 = (Ogre::ResourceGroupManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceLoadingListener *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_Ogre__ResourceGroupManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceGroupManager *","getLoadingListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceGroupManager * >(argp1);
  result = (Ogre::ResourceLoadingListener *)(arg1)->getLoadingListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceLoadingListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ResourceGroupManager *) &Ogre::ResourceGroupManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceGroupManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceGroupManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceGroupManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ResourceGroupManager *)Ogre::ResourceGroupManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceGroupManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassScriptLoader;

SWIGINTERN void
free_Ogre_ScriptLoader(Ogre::ScriptLoader *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ScriptLoader_getScriptPatterns(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptLoader *arg1 = (Ogre::ScriptLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__ScriptLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptLoader const *","getScriptPatterns", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptLoader * >(argp1);
  result = (Ogre::StringVector *) &((Ogre::ScriptLoader const *)arg1)->getScriptPatterns();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptLoader_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptLoader *arg1 = (Ogre::ScriptLoader *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ScriptLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptLoader *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptLoader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptLoader_getLoadingOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptLoader *arg1 = (Ogre::ScriptLoader *) 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_Ogre__ScriptLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptLoader const *","getLoadingOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptLoader * >(argp1);
  result = (Ogre::Real)((Ogre::ScriptLoader const *)arg1)->getLoadingOrder();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassResourcePool;

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

SWIGINTERN VALUE
_wrap_new_ResourcePool(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::ResourcePool";
  ResourcePool *result = 0 ;
  
  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 &","ResourcePool", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","ResourcePool", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (ResourcePool *)new ResourcePool((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_ResourcePool(ResourcePool *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ResourcePool_getName(int argc, VALUE *argv, VALUE self) {
  ResourcePool *arg1 = (ResourcePool *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_ResourcePool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ResourcePool const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< ResourcePool * >(argp1);
  result = (Ogre::String *) &((ResourcePool const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ResourcePool.clear

  call-seq:
    clear

Clear ResourcePool contents.
*/
SWIGINTERN VALUE
_wrap_ResourcePool_clear(int argc, VALUE *argv, VALUE self) {
  ResourcePool *arg1 = (ResourcePool *) 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_ResourcePool, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "ResourcePool *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< ResourcePool * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassResourceManager;

SWIGINTERN void
free_Ogre_ResourceManager(Ogre::ResourceManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ResourceManager_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Ogre::ResourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","create", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","create", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","create", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_create__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Ogre::ResourcePtr result;
  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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","create", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","create", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_create__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","create", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_create__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_create(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__ResourceManager, 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_ResourceManager_create__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceManager_create__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceManager_create__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ResourceManager_create__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ResourceManager.create", 
    "    Ogre::ResourcePtr ResourceManager.create(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams)\n"
    "    Ogre::ResourcePtr ResourceManager.create(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourcePtr ResourceManager.create(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourcePtr ResourceManager.create(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_createOrRetrieve__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_ResourceManager_createOrRetrieve__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_ResourceManager_createOrRetrieve__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_ResourceManager_createOrRetrieve__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_ResourceManager_createOrRetrieve(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__ResourceManager, 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_ResourceManager_createOrRetrieve__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceManager_createOrRetrieve__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceManager_createOrRetrieve__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ResourceManager_createOrRetrieve__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ResourceManager.createOrRetrieve", 
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult ResourceManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_setMemoryBudget(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","setMemoryBudget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setMemoryBudget", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setMemoryBudget(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getMemoryBudget(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager const *","getMemoryBudget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  result = ((Ogre::ResourceManager const *)arg1)->getMemoryBudget();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getMemoryUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager const *","getMemoryUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  result = ((Ogre::ResourceManager const *)arg1)->getMemoryUsage();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unload__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","unload", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unload((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unload__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::ResourceHandle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","unload", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ResourceHandle >(val2);
  (arg1)->unload(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_unload(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_unload__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_ResourceManager_unload__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.unload", 
    "    void ResourceManager.unload(Ogre::String const &name)\n"
    "    void ResourceManager.unload(Ogre::ResourceHandle handle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unloadAll__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","unloadAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","unloadAll", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->unloadAll(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unloadAll__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","unloadAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  (arg1)->unloadAll();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_unloadAll(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceManager_unloadAll__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_unloadAll__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.unloadAll", 
    "    void ResourceManager.unloadAll(bool reloadableOnly)\n"
    "    void ResourceManager.unloadAll()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_reloadAll__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","reloadAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","reloadAll", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->reloadAll(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_reloadAll__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","reloadAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  (arg1)->reloadAll();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_reloadAll(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceManager_reloadAll__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_reloadAll__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.reloadAll", 
    "    void ResourceManager.reloadAll(bool reloadableOnly)\n"
    "    void ResourceManager.reloadAll()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unloadUnreferencedResources__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","unloadUnreferencedResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","unloadUnreferencedResources", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->unloadUnreferencedResources(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_unloadUnreferencedResources__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","unloadUnreferencedResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  (arg1)->unloadUnreferencedResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_unloadUnreferencedResources(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceManager_unloadUnreferencedResources__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_unloadUnreferencedResources__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.unloadUnreferencedResources", 
    "    void ResourceManager.unloadUnreferencedResources(bool reloadableOnly)\n"
    "    void ResourceManager.unloadUnreferencedResources()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_reloadUnreferencedResources__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","reloadUnreferencedResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","reloadUnreferencedResources", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->reloadUnreferencedResources(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_reloadUnreferencedResources__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","reloadUnreferencedResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  (arg1)->reloadUnreferencedResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_reloadUnreferencedResources(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceManager_reloadUnreferencedResources__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_reloadUnreferencedResources__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.reloadUnreferencedResources", 
    "    void ResourceManager.reloadUnreferencedResources(bool reloadableOnly)\n"
    "    void ResourceManager.reloadUnreferencedResources()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_remove__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::ResourcePtr *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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","remove", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourcePtr &","remove", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr &","remove", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ResourcePtr * >(argp2);
  (arg1)->remove(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_remove__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","remove", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","remove", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","remove", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->remove((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_remove__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::ResourceHandle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","remove", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","remove", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ResourceHandle >(val2);
  (arg1)->remove(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_remove(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ResourceManager_remove__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_remove__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_ResourceManager_remove__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.remove", 
    "    void ResourceManager.remove(Ogre::ResourcePtr &r)\n"
    "    void ResourceManager.remove(Ogre::String const &name)\n"
    "    void ResourceManager.remove(Ogre::ResourceHandle handle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_removeAll(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","removeAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  (arg1)->removeAll();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_removeUnreferencedResources__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","removeUnreferencedResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","removeUnreferencedResources", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->removeUnreferencedResources(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_removeUnreferencedResources__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","removeUnreferencedResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  (arg1)->removeUnreferencedResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_removeUnreferencedResources(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceManager_removeUnreferencedResources__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_removeUnreferencedResources__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.removeUnreferencedResources", 
    "    void ResourceManager.removeUnreferencedResources(bool reloadableOnly)\n"
    "    void ResourceManager.removeUnreferencedResources()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getByName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","getByName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","getByName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getByName", 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 &","getByName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getByName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->getByName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_getByName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","getByName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","getByName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getByName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getByName((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_getByName(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_Ogre__ResourceManager, 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_ResourceManager_getByName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_ResourceManager_getByName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceManager.getByName", 
    "    Ogre::ResourcePtr ResourceManager.getByName(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    Ogre::ResourcePtr ResourceManager.getByName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getByHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::ResourceHandle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 0 ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","getByHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","getByHandle", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ResourceHandle >(val2);
  result = (arg1)->getByHandle(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_resourceExists__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","resourceExists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","resourceExists", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","resourceExists", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->resourceExists((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_resourceExists__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::ResourceHandle arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","resourceExists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","resourceExists", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ResourceHandle >(val2);
  result = (bool)(arg1)->resourceExists(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_resourceExists(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ResourceManager_resourceExists__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_ResourceManager_resourceExists__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.resourceExists", 
    "    bool ResourceManager.resourceExists(Ogre::String const &name)\n"
    "    bool ResourceManager.resourceExists(Ogre::ResourceHandle handle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager__notifyResourceTouched(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","_notifyResourceTouched", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","_notifyResourceTouched", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->_notifyResourceTouched(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager__notifyResourceLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","_notifyResourceLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","_notifyResourceLoaded", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->_notifyResourceLoaded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager__notifyResourceUnloaded(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","_notifyResourceUnloaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","_notifyResourceUnloaded", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->_notifyResourceUnloaded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Ogre::ResourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","prepare", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","prepare", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","prepare", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Ogre::ResourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","prepare", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","prepare", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_prepare__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Ogre::ResourcePtr result;
  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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","prepare", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_prepare__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_prepare__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_prepare(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__ResourceManager, 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_ResourceManager_prepare__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceManager_prepare__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceManager_prepare__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ResourceManager_prepare__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ResourceManager_prepare__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "ResourceManager.prepare", 
    "    Ogre::ResourcePtr ResourceManager.prepare(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams, bool backgroundThread)\n"
    "    Ogre::ResourcePtr ResourceManager.prepare(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams)\n"
    "    Ogre::ResourcePtr ResourceManager.prepare(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourcePtr ResourceManager.prepare(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourcePtr ResourceManager.prepare(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Ogre::ResourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","load", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","load", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","load", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","load", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Ogre::ResourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","load", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","load", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","load", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Ogre::ResourcePtr result;
  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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","load", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","load", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_load__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","load", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_load__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::ResourcePtr 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 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_ResourceManager_load(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__ResourceManager, 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_ResourceManager_load__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ResourceManager_load__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ResourceManager_load__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ResourceManager_load__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ResourceManager_load__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "ResourceManager.load", 
    "    Ogre::ResourcePtr ResourceManager.load(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams, bool backgroundThread)\n"
    "    Ogre::ResourcePtr ResourceManager.load(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams)\n"
    "    Ogre::ResourcePtr ResourceManager.load(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourcePtr ResourceManager.load(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourcePtr ResourceManager.load(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getScriptPatterns(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager const *","getScriptPatterns", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  result = (Ogre::StringVector *) &((Ogre::ResourceManager const *)arg1)->getScriptPatterns();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getLoadingOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager const *","getLoadingOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  result = (Ogre::Real)((Ogre::ResourceManager const *)arg1)->getLoadingOrder();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getResourceType(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager const *","getResourceType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  result = (Ogre::String *) &((Ogre::ResourceManager const *)arg1)->getResourceType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_setVerbose(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","setVerbose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVerbose", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVerbose(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getVerbose(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","getVerbose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  result = (bool)(arg1)->getVerbose();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getResourcePool(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ResourceManager::ResourcePool *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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","getResourcePool", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","getResourcePool", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getResourcePool", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ResourceManager::ResourcePool *)(arg1)->getResourcePool((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager__ResourcePool, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_destroyResourcePool__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::ResourceManager::ResourcePool *arg2 = (Ogre::ResourceManager::ResourcePool *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","destroyResourcePool", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ResourceManager__ResourcePool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourceManager::ResourcePool *","destroyResourcePool", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ResourceManager::ResourcePool * >(argp2);
  (arg1)->destroyResourcePool(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_destroyResourcePool__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","destroyResourcePool", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(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( "", "Ogre::String const &","destroyResourcePool", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyResourcePool", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyResourcePool((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceManager_destroyResourcePool(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_Ogre__ResourceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ResourceManager__ResourcePool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ResourceManager_destroyResourcePool__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_ResourceManager_destroyResourcePool__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceManager.destroyResourcePool", 
    "    void ResourceManager.destroyResourcePool(Ogre::ResourceManager::ResourcePool *pool)\n"
    "    void ResourceManager.destroyResourcePool(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_destroyAllResourcePools(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","destroyAllResourcePools", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  (arg1)->destroyAllResourcePools();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceManager_getResourceIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ResourceManager::ResourceMapIterator > 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_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","getResourceIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  result = (arg1)->getResourceIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceMapIterator(static_cast< const Ogre::ResourceManager::ResourceMapIterator& >(result))), SWIGTYPE_p_Ogre__ResourceManager__ResourceMapIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassArchiveManager;

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

SWIGINTERN VALUE
_wrap_new_ArchiveManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ArchiveManager";
  Ogre::ArchiveManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ArchiveManager *)new Ogre::ArchiveManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ArchiveManager(Ogre::ArchiveManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ArchiveManager_load(int argc, VALUE *argv, VALUE self) {
  Ogre::ArchiveManager *arg1 = (Ogre::ArchiveManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::Archive *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_Ogre__ArchiveManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ArchiveManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ArchiveManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Archive *)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Archive, 0 |  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_ArchiveManager_unload__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ArchiveManager *arg1 = (Ogre::ArchiveManager *) 0 ;
  Ogre::Archive *arg2 = (Ogre::Archive *) 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_Ogre__ArchiveManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ArchiveManager *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ArchiveManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Archive *","unload", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Archive * >(argp2);
  (arg1)->unload(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ArchiveManager_unload__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ArchiveManager *arg1 = (Ogre::ArchiveManager *) 0 ;
  Ogre::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_Ogre__ArchiveManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ArchiveManager *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ArchiveManager * >(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( "", "Ogre::String const &","unload", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unload((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ArchiveManager_unload(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_Ogre__ArchiveManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Archive, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ArchiveManager_unload__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ArchiveManager, 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_ArchiveManager_unload__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ArchiveManager.unload", 
    "    void ArchiveManager.unload(Ogre::Archive *arch)\n"
    "    void ArchiveManager.unload(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ArchiveManager_getArchiveIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ArchiveManager *arg1 = (Ogre::ArchiveManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::Archive *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::Archive * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ArchiveManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ArchiveManager *","getArchiveIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ArchiveManager * >(argp1);
  result = (arg1)->getArchiveIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ArchiveManager::ArchiveMapIterator(static_cast< const Ogre::ArchiveManager::ArchiveMapIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ArchiveManager_addArchiveFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::ArchiveManager *arg1 = (Ogre::ArchiveManager *) 0 ;
  Ogre::ArchiveFactory *arg2 = (Ogre::ArchiveFactory *) 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_Ogre__ArchiveManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ArchiveManager *","addArchiveFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ArchiveManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ArchiveFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ArchiveFactory *","addArchiveFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ArchiveFactory * >(argp2);
  (arg1)->addArchiveFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ArchiveManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ArchiveManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ArchiveManager *) &Ogre::ArchiveManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ArchiveManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ArchiveManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ArchiveManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ArchiveManager *)Ogre::ArchiveManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ArchiveManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRenderQueue;

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

SWIGINTERN VALUE
_wrap_new_RenderQueue(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderQueue";
  Ogre::RenderQueue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderQueue *)new Ogre::RenderQueue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderQueue(Ogre::RenderQueue *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::RenderQueue.clear

  call-seq:
    clear(destroyPassMaps=false)
    clear

Clear RenderQueue contents.
*/
SWIGINTERN VALUE
_wrap_RenderQueue_clear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","clear", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->clear(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_clear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderQueue_clear(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_Ogre__RenderQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderQueue_clear__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderQueue_clear__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderQueue.clear", 
    "    void RenderQueue.clear(bool destroyPassMaps)\n"
    "    void RenderQueue.clear()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_getQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Ogre::RenderQueueGroup *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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","getQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::RenderQueueGroup *)(arg1)->getQueueGroup(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueGroup, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_addRenderable__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::uint8 arg3 ;
  Ogre::ushort arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","addRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","addRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","addRenderable", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::ushort","addRenderable", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::ushort >(val4);
  (arg1)->addRenderable(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_addRenderable__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::uint8 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","addRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","addRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","addRenderable", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  (arg1)->addRenderable(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_addRenderable__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","addRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","addRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  (arg1)->addRenderable(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderQueue_addRenderable(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_Ogre__RenderQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RenderQueue_addRenderable__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderQueue_addRenderable__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RenderQueue_addRenderable__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderQueue.addRenderable", 
    "    void RenderQueue.addRenderable(Ogre::Renderable *pRend, Ogre::uint8 groupID, Ogre::ushort priority)\n"
    "    void RenderQueue.addRenderable(Ogre::Renderable *pRend, Ogre::uint8 groupId)\n"
    "    void RenderQueue.addRenderable(Ogre::Renderable *pRend)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_getDefaultQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","getDefaultQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = (Ogre::uint8)((Ogre::RenderQueue const *)arg1)->getDefaultQueueGroup();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_setDefaultRenderablePriority(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","setDefaultRenderablePriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setDefaultRenderablePriority", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setDefaultRenderablePriority(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_getDefaultRenderablePriority(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","getDefaultRenderablePriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderQueue const *)arg1)->getDefaultRenderablePriority();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_setDefaultQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","setDefaultQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setDefaultQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setDefaultQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue__getQueueGroupIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::RenderQueue::RenderQueueGroupMap > > 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_getQueueGroupIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = (arg1)->_getQueueGroupIterator();
  vresult = SWIG_NewPointerObj((new Ogre::RenderQueue::QueueGroupIterator(static_cast< const Ogre::RenderQueue::QueueGroupIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue__getQueueGroupIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::RenderQueue::RenderQueueGroupMap > > 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","_getQueueGroupIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = ((Ogre::RenderQueue const *)arg1)->_getQueueGroupIterator();
  vresult = SWIG_NewPointerObj((new Ogre::RenderQueue::ConstQueueGroupIterator(static_cast< const Ogre::RenderQueue::ConstQueueGroupIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__RenderQueueGroupMap_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderQueue__getQueueGroupIterator(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_Ogre__RenderQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderQueue__getQueueGroupIterator__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderQueue__getQueueGroupIterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RenderQueue._getQueueGroupIterator", 
    "    Ogre::RenderQueue::ConstQueueGroupIterator RenderQueue._getQueueGroupIterator()\n"
    "    Ogre::RenderQueue::ConstQueueGroupIterator RenderQueue._getQueueGroupIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_setSplitPassesByLightingType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","setSplitPassesByLightingType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitPassesByLightingType", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitPassesByLightingType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_getSplitPassesByLightingType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","getSplitPassesByLightingType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = (bool)((Ogre::RenderQueue const *)arg1)->getSplitPassesByLightingType();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_setSplitNoShadowPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","setSplitNoShadowPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitNoShadowPasses", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitNoShadowPasses(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_getSplitNoShadowPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","getSplitNoShadowPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = (bool)((Ogre::RenderQueue const *)arg1)->getSplitNoShadowPasses();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_setShadowCastersCannotBeReceivers(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","setShadowCastersCannotBeReceivers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowCastersCannotBeReceivers", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowCastersCannotBeReceivers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_getShadowCastersCannotBeReceivers(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","getShadowCastersCannotBeReceivers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = (bool)((Ogre::RenderQueue const *)arg1)->getShadowCastersCannotBeReceivers();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_setRenderableListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::RenderQueue::RenderableListener *arg2 = (Ogre::RenderQueue::RenderableListener *) 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","setRenderableListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue__RenderableListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue::RenderableListener *","setRenderableListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue::RenderableListener * >(argp2);
  (arg1)->setRenderableListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_getRenderableListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderQueue::RenderableListener *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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","getRenderableListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  result = (Ogre::RenderQueue::RenderableListener *)((Ogre::RenderQueue const *)arg1)->getRenderableListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueue__RenderableListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_merge(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue const *","merge", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->merge((Ogre::RenderQueue const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueue_processVisibleObject(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  bool arg4 ;
  Ogre::VisibleObjectsBoundsInfo *arg5 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","processVisibleObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","processVisibleObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera *","processVisibleObject", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","processVisibleObject", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","processVisibleObject", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp5);
  (arg1)->processVisibleObject(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassAxisAlignedBox;

SWIGINTERN VALUE
_wrap_new_AxisAlignedBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::AxisAlignedBox";
  Ogre::AxisAlignedBox *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_AxisAlignedBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox::Extent arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AxisAlignedBox";
  Ogre::AxisAlignedBox *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( "", "Ogre::AxisAlignedBox::Extent","Ogre::AxisAlignedBox", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::AxisAlignedBox::Extent >(val1);
  result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_AxisAlignedBox__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AxisAlignedBox";
  Ogre::AxisAlignedBox *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__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","Ogre::AxisAlignedBox", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","Ogre::AxisAlignedBox", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox((Ogre::AxisAlignedBox const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_AxisAlignedBox__SWIG_3(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 = "Ogre::AxisAlignedBox";
  Ogre::AxisAlignedBox *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 &","Ogre::AxisAlignedBox", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::AxisAlignedBox", 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 &","Ogre::AxisAlignedBox", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::AxisAlignedBox", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_AxisAlignedBox__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AxisAlignedBox";
  Ogre::AxisAlignedBox *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","Ogre::AxisAlignedBox", 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","Ogre::AxisAlignedBox", 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","Ogre::AxisAlignedBox", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AxisAlignedBox", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AxisAlignedBox", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::AxisAlignedBox", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (Ogre::AxisAlignedBox *)new Ogre::AxisAlignedBox(arg1,arg2,arg3,arg4,arg5,arg6);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AxisAlignedBox(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_AxisAlignedBox__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_AxisAlignedBox__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_AxisAlignedBox__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_new_AxisAlignedBox__SWIG_3(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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_AxisAlignedBox__SWIG_4(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "AxisAlignedBox.new", 
    "    AxisAlignedBox.new()\n"
    "    AxisAlignedBox.new(Ogre::AxisAlignedBox::Extent e)\n"
    "    AxisAlignedBox.new(Ogre::AxisAlignedBox const &rkBox)\n"
    "    AxisAlignedBox.new(Ogre::Vector3 const &min, Ogre::Vector3 const &max)\n"
    "    AxisAlignedBox.new(Ogre::Real mx, Ogre::Real my, Ogre::Real mz, Ogre::Real Mx, Ogre::Real My, Ogre::Real Mz)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_AxisAlignedBox(Ogre::AxisAlignedBox *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AxisAlignedBox_getMinimum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","getMinimum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::AxisAlignedBox const *)arg1)->getMinimum();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_getMinimum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","getMinimum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::Vector3 *) &(arg1)->getMinimum();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_getMinimum(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_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_AxisAlignedBox_getMinimum__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_AxisAlignedBox_getMinimum__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "AxisAlignedBox.getMinimum", 
    "    Ogre::Vector3 & AxisAlignedBox.getMinimum()\n"
    "    Ogre::Vector3 & AxisAlignedBox.getMinimum()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_getMaximum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","getMaximum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::AxisAlignedBox const *)arg1)->getMaximum();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_getMaximum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","getMaximum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::Vector3 *) &(arg1)->getMaximum();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_getMaximum(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_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_AxisAlignedBox_getMaximum__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_AxisAlignedBox_getMaximum__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "AxisAlignedBox.getMaximum", 
    "    Ogre::Vector3 & AxisAlignedBox.getMaximum()\n"
    "    Ogre::Vector3 & AxisAlignedBox.getMaximum()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMinimum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Vector3 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMinimum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","setMinimum", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setMinimum", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setMinimum((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMinimum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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 ;
  
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMinimum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinimum", 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","setMinimum", 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","setMinimum", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setMinimum(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_setMinimum(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_Ogre__AxisAlignedBox, 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_AxisAlignedBox_setMinimum__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 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_AxisAlignedBox_setMinimum__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "AxisAlignedBox.setMinimum", 
    "    void AxisAlignedBox.setMinimum(Ogre::Vector3 const &vec)\n"
    "    void AxisAlignedBox.setMinimum(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMinimumX(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMinimumX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinimumX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMinimumX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMinimumY(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMinimumY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinimumY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMinimumY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMinimumZ(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMinimumZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinimumZ", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMinimumZ(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMaximum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Vector3 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMaximum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","setMaximum", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setMaximum", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setMaximum((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMaximum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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 ;
  
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMaximum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaximum", 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","setMaximum", 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","setMaximum", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setMaximum(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_setMaximum(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_Ogre__AxisAlignedBox, 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_AxisAlignedBox_setMaximum__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 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_AxisAlignedBox_setMaximum__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "AxisAlignedBox.setMaximum", 
    "    void AxisAlignedBox.setMaximum(Ogre::Vector3 const &vec)\n"
    "    void AxisAlignedBox.setMaximum(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMaximumX(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMaximumX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaximumX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaximumX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMaximumY(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMaximumY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaximumY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaximumY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setMaximumZ(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setMaximumZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaximumZ", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaximumZ(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setExtents__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setExtents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","setExtents", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setExtents", 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 &","setExtents", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setExtents", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->setExtents((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setExtents__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setExtents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setExtents", 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","setExtents", 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","setExtents", 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","setExtents", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setExtents", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setExtents", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setExtents(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_setExtents(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__AxisAlignedBox, 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_AxisAlignedBox_setExtents__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_AxisAlignedBox_setExtents__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "AxisAlignedBox.setExtents", 
    "    void AxisAlignedBox.setExtents(Ogre::Vector3 const &min, Ogre::Vector3 const &max)\n"
    "    void AxisAlignedBox.setExtents(Ogre::Real mx, Ogre::Real my, Ogre::Real mz, Ogre::Real Mx, Ogre::Real My, Ogre::Real Mz)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_getAllCorners(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","getAllCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::Vector3 *)((Ogre::AxisAlignedBox const *)arg1)->getAllCorners();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_getCorner(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::AxisAlignedBox::CornerEnum arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","getCorner", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox::CornerEnum","getCorner", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::AxisAlignedBox::CornerEnum >(val2);
  result = ((Ogre::AxisAlignedBox const *)arg1)->getCorner(arg2);
  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_AxisAlignedBox_merge__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","merge", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","merge", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->merge((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_merge__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Vector3 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","merge", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","merge", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->merge((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_merge(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_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AxisAlignedBox_merge__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 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_AxisAlignedBox_merge__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AxisAlignedBox.merge", 
    "    void AxisAlignedBox.merge(Ogre::AxisAlignedBox const &rhs)\n"
    "    void AxisAlignedBox.merge(Ogre::Vector3 const &point)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_transform(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Matrix4 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","transform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","transform", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","transform", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->transform((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_transformAffine(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Matrix4 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","transformAffine", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","transformAffine", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","transformAffine", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->transformAffine((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setNull(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  (arg1)->setNull();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_isNull(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","isNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->isNull();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_isFinite(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","isFinite", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->isFinite();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_setInfinite(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","setInfinite", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  (arg1)->setInfinite();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_isInfinite(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","isInfinite", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->isInfinite();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_intersects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_intersection(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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(self, &argp1,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","intersection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","intersection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","intersection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = ((Ogre::AxisAlignedBox const *)arg1)->intersection((Ogre::AxisAlignedBox const &)*arg2);
  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_AxisAlignedBox_volume(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","volume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = (Ogre::Real)((Ogre::AxisAlignedBox const *)arg1)->volume();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_scale(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Vector3 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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);
  (arg1)->scale((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_intersects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Sphere *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_intersects__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Plane *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::Plane const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_intersects__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Vector3 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->intersects((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_intersects(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_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AxisAlignedBox_intersects__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AxisAlignedBox_intersects__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AxisAlignedBox_intersects__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 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_AxisAlignedBox_intersects__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AxisAlignedBox.intersects", 
    "    bool AxisAlignedBox.intersects(Ogre::AxisAlignedBox const &b2)\n"
    "    bool AxisAlignedBox.intersects(Ogre::Sphere const &s)\n"
    "    bool AxisAlignedBox.intersects(Ogre::Plane const &p)\n"
    "    bool AxisAlignedBox.intersects(Ogre::Vector3 const &v)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_getCenter(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","getCenter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = ((Ogre::AxisAlignedBox const *)arg1)->getCenter();
  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_AxisAlignedBox_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = ((Ogre::AxisAlignedBox const *)arg1)->getSize();
  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_AxisAlignedBox_getHalfSize(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","getHalfSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  result = ((Ogre::AxisAlignedBox const *)arg1)->getHalfSize();
  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_AxisAlignedBox_contains__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Vector3 *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","contains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","contains", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","contains", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->contains((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_distance(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","distance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(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 &","distance", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","distance", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Real)((Ogre::AxisAlignedBox const *)arg1)->distance((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_contains__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","contains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","contains", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","contains", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->contains((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_AxisAlignedBox_contains(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_Ogre__AxisAlignedBox, 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_AxisAlignedBox_contains__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_AxisAlignedBox_contains__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "AxisAlignedBox.contains", 
    "    bool AxisAlignedBox.contains(Ogre::Vector3 const &v)\n"
    "    bool AxisAlignedBox.contains(Ogre::AxisAlignedBox const &other)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::AxisAlignedBox.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_AxisAlignedBox___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBox *arg1 = (Ogre::AxisAlignedBox *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)((Ogre::AxisAlignedBox const *)arg1)->operator ==((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_BOX_NULL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::AxisAlignedBox::BOX_NULL), SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBox_BOX_INFINITE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::AxisAlignedBox::BOX_INFINITE), SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  return _val;
}


swig_class SwigClassSphere;

SWIGINTERN VALUE
_wrap_new_Sphere__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Sphere";
  Ogre::Sphere *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Sphere *)new Ogre::Sphere();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Sphere__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Sphere";
  Ogre::Sphere *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 &","Ogre::Sphere", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Sphere", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Sphere", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Sphere *)new Ogre::Sphere((Ogre::Vector3 const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Sphere(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_Sphere__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) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Sphere__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Sphere.new", 
    "    Sphere.new()\n"
    "    Sphere.new(Ogre::Vector3 const &center, Ogre::Real radius)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_getRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const *","getRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  result = (Ogre::Real)((Ogre::Sphere const *)arg1)->getRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_setRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere *","setRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(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);
  (arg1)->setRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_getCenter(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const *","getCenter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Sphere const *)arg1)->getCenter();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_setCenter(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  Ogre::Vector3 *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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere *","setCenter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(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 &","setCenter", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setCenter", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setCenter((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_intersects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  Ogre::Sphere *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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_intersects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_intersects__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  Ogre::Plane *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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::Plane const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_intersects__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  Ogre::Vector3 *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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(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 &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Sphere const *)arg1)->intersects((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Sphere_intersects(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_Ogre__Sphere, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Sphere_intersects__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Sphere_intersects__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Sphere_intersects__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Sphere, 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_Sphere_intersects__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Sphere.intersects", 
    "    bool Sphere.intersects(Ogre::Sphere const &s)\n"
    "    bool Sphere.intersects(Ogre::AxisAlignedBox const &box)\n"
    "    bool Sphere.intersects(Ogre::Plane const &plane)\n"
    "    bool Sphere.intersects(Ogre::Vector3 const &v)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Sphere_merge(int argc, VALUE *argv, VALUE self) {
  Ogre::Sphere *arg1 = (Ogre::Sphere *) 0 ;
  Ogre::Sphere *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_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Sphere *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Sphere * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","merge", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","merge", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  (arg1)->merge((Ogre::Sphere const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Sphere(Ogre::Sphere *arg1) {
    delete arg1;
}

swig_class SwigClassHardwareIndexBuffer;

SWIGINTERN void
free_Ogre_HardwareIndexBuffer(Ogre::HardwareIndexBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareIndexBuffer *arg1 = (Ogre::HardwareIndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareBufferManagerBase *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_Ogre__HardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareIndexBuffer * >(argp1);
  result = (Ogre::HardwareBufferManagerBase *)((Ogre::HardwareIndexBuffer const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareIndexBuffer *arg1 = (Ogre::HardwareIndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareIndexBuffer::IndexType 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_Ogre__HardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareIndexBuffer * >(argp1);
  result = (Ogre::HardwareIndexBuffer::IndexType)((Ogre::HardwareIndexBuffer const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_getNumIndexes(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareIndexBuffer *arg1 = (Ogre::HardwareIndexBuffer *) 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_Ogre__HardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer const *","getNumIndexes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareIndexBuffer * >(argp1);
  result = ((Ogre::HardwareIndexBuffer const *)arg1)->getNumIndexes();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareIndexBuffer_getIndexSize(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareIndexBuffer *arg1 = (Ogre::HardwareIndexBuffer *) 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_Ogre__HardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer const *","getIndexSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareIndexBuffer * >(argp1);
  result = ((Ogre::HardwareIndexBuffer const *)arg1)->getIndexSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassHardwareIndexBufferSharedPtr;

SWIGINTERN VALUE
_wrap_new_HardwareIndexBufferSharedPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::HardwareIndexBufferSharedPtr";
  Ogre::HardwareIndexBufferSharedPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HardwareIndexBufferSharedPtr *)new Ogre::HardwareIndexBufferSharedPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_HardwareIndexBufferSharedPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareIndexBuffer *arg1 = (Ogre::HardwareIndexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::HardwareIndexBufferSharedPtr";
  Ogre::HardwareIndexBufferSharedPtr *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__HardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer *","Ogre::HardwareIndexBufferSharedPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareIndexBuffer * >(argp1);
  result = (Ogre::HardwareIndexBufferSharedPtr *)new Ogre::HardwareIndexBufferSharedPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HardwareIndexBufferSharedPtr(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_HardwareIndexBufferSharedPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HardwareIndexBufferSharedPtr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HardwareIndexBufferSharedPtr.new", 
    "    HardwareIndexBufferSharedPtr.new()\n"
    "    HardwareIndexBufferSharedPtr.new(Ogre::HardwareIndexBuffer *buf)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_HardwareIndexBufferSharedPtr(Ogre::HardwareIndexBufferSharedPtr *arg1) {
    delete arg1;
}

swig_class SwigClassVertexData;

SWIGINTERN VALUE
_wrap_new_VertexData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexData";
  Ogre::VertexData *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__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","Ogre::VertexData", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  result = (Ogre::VertexData *)new Ogre::VertexData(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_VertexData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::VertexData";
  Ogre::VertexData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VertexData *)new Ogre::VertexData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VertexData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexDeclaration *arg1 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::VertexBufferBinding *arg2 = (Ogre::VertexBufferBinding *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexData";
  Ogre::VertexData *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__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","Ogre::VertexData", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","Ogre::VertexData", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp2);
  result = (Ogre::VertexData *)new Ogre::VertexData(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_VertexData(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_VertexData__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_VertexData__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexBufferBinding, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_VertexData__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "VertexData.new", 
    "    VertexData.new(Ogre::HardwareBufferManagerBase *mgr)\n"
    "    VertexData.new()\n"
    "    VertexData.new(Ogre::VertexDeclaration *dcl, Ogre::VertexBufferBinding *bind)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexData(Ogre::VertexData *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_VertexData_vertexDeclaration_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","vertexDeclaration", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  if (arg1) (arg1)->vertexDeclaration = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_vertexDeclaration_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result = (Ogre::VertexDeclaration *) ((arg1)->vertexDeclaration);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_vertexBufferBinding_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexBufferBinding *arg2 = (Ogre::VertexBufferBinding *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexBufferBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexBufferBinding, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","vertexBufferBinding", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp2);
  if (arg1) (arg1)->vertexBufferBinding = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_vertexBufferBinding_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexBufferBinding *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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexBufferBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result = (Ogre::VertexBufferBinding *) ((arg1)->vertexBufferBinding);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_mDeleteDclBinding_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","mDeleteDclBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mDeleteDclBinding", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->mDeleteDclBinding = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_mDeleteDclBinding_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","mDeleteDclBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result = (bool) ((arg1)->mDeleteDclBinding);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_vertexStart_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","vertexStart", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->vertexStart = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_vertexStart_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result =  ((arg1)->vertexStart);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_vertexCount_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","vertexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->vertexCount = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_vertexCount_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result =  ((arg1)->vertexCount);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_hwAnimationDataList_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexData::HardwareAnimationDataList *arg2 = (Ogre::VertexData::HardwareAnimationDataList *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","hwAnimationDataList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData::HardwareAnimationDataList *","hwAnimationDataList", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData::HardwareAnimationDataList * >(argp2);
  if (arg1) (arg1)->hwAnimationDataList = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_hwAnimationDataList_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData::HardwareAnimationDataList *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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","hwAnimationDataList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result = (Ogre::VertexData::HardwareAnimationDataList *)& ((arg1)->hwAnimationDataList);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_hwAnimDataItemsUsed_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","hwAnimDataItemsUsed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","hwAnimDataItemsUsed", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->hwAnimDataItemsUsed = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_hwAnimDataItemsUsed_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","hwAnimDataItemsUsed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result =  ((arg1)->hwAnimDataItemsUsed);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VertexData.clone

  call-seq:
    clone(copyData=true, mgr=0) -> VertexData
    clone(copyData=true) -> VertexData
    clone -> VertexData

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_VertexData_clone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  bool arg2 ;
  Ogre::HardwareBufferManagerBase *arg3 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::VertexData *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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","clone", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","clone", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp3);
  result = (Ogre::VertexData *)((Ogre::VertexData const *)arg1)->clone(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_clone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::VertexData *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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","clone", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::VertexData *)((Ogre::VertexData const *)arg1)->clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_clone__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result = (Ogre::VertexData *)((Ogre::VertexData const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexData_clone(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_Ogre__VertexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_VertexData_clone__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_VertexData_clone__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexData_clone__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "VertexData.clone", 
    "    Ogre::VertexData * VertexData.clone(bool copyData, Ogre::HardwareBufferManagerBase *mgr)\n"
    "    Ogre::VertexData * VertexData.clone(bool copyData)\n"
    "    Ogre::VertexData * VertexData.clone()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_prepareForShadowVolume(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","prepareForShadowVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  (arg1)->prepareForShadowVolume();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_hardwareShadowVolWBuffer_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = (Ogre::HardwareVertexBufferSharedPtr *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","hardwareShadowVolWBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr *","hardwareShadowVolWBuffer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  if (arg1) (arg1)->hardwareShadowVolWBuffer = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_hardwareShadowVolWBuffer_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","hardwareShadowVolWBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  result = (Ogre::HardwareVertexBufferSharedPtr *)& ((arg1)->hardwareShadowVolWBuffer);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_reorganiseBuffers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::BufferUsageList *arg3 = 0 ;
  Ogre::HardwareBufferManagerBase *arg4 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","reorganiseBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","reorganiseBuffers", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::BufferUsageList const &","reorganiseBuffers", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::BufferUsageList const &","reorganiseBuffers", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::BufferUsageList * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","reorganiseBuffers", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp4);
  (arg1)->reorganiseBuffers(arg2,(Ogre::BufferUsageList const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_reorganiseBuffers__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::BufferUsageList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","reorganiseBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","reorganiseBuffers", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::BufferUsageList const &","reorganiseBuffers", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::BufferUsageList const &","reorganiseBuffers", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::BufferUsageList * >(argp3);
  (arg1)->reorganiseBuffers(arg2,(Ogre::BufferUsageList const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_reorganiseBuffers__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 0 ;
  Ogre::HardwareBufferManagerBase *arg3 = (Ogre::HardwareBufferManagerBase *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","reorganiseBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","reorganiseBuffers", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","reorganiseBuffers", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp3);
  (arg1)->reorganiseBuffers(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_reorganiseBuffers__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","reorganiseBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","reorganiseBuffers", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  (arg1)->reorganiseBuffers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VertexData_reorganiseBuffers(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_Ogre__VertexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_VertexData_reorganiseBuffers__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexData_reorganiseBuffers__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_VertexData_reorganiseBuffers__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VertexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__HardwareBuffer__Usage_Ogre__STLAllocatorT_Ogre__HardwareBuffer__Usage_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VertexData_reorganiseBuffers__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "VertexData.reorganiseBuffers", 
    "    void VertexData.reorganiseBuffers(Ogre::VertexDeclaration *newDeclaration, Ogre::BufferUsageList const &bufferUsage, Ogre::HardwareBufferManagerBase *mgr)\n"
    "    void VertexData.reorganiseBuffers(Ogre::VertexDeclaration *newDeclaration, Ogre::BufferUsageList const &bufferUsage)\n"
    "    void VertexData.reorganiseBuffers(Ogre::VertexDeclaration *newDeclaration, Ogre::HardwareBufferManagerBase *mgr)\n"
    "    void VertexData.reorganiseBuffers(Ogre::VertexDeclaration *newDeclaration)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_closeGapsInBindings(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","closeGapsInBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  (arg1)->closeGapsInBindings();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_removeUnusedBuffers(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","removeUnusedBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  (arg1)->removeUnusedBuffers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_convertPackedColour(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexElementType arg2 ;
  Ogre::VertexElementType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","convertPackedColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementType","convertPackedColour", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::VertexElementType","convertPackedColour", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::VertexElementType >(val3);
  (arg1)->convertPackedColour(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexData_allocateHardwareAnimationElements(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::ushort arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::ushort 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_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData *","allocateHardwareAnimationElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","allocateHardwareAnimationElements", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","allocateHardwareAnimationElements", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::ushort)(arg1)->allocateHardwareAnimationElements(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassIndexData;

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

SWIGINTERN VALUE
_wrap_new_IndexData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::IndexData";
  Ogre::IndexData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::IndexData *)new Ogre::IndexData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_IndexData(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_IndexData__SWIG_1(nargs, args, self);
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "new_IndexData.new", 
    "    new_IndexData.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_IndexData(Ogre::IndexData *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_IndexData_indexBuffer_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg2 = (Ogre::HardwareIndexBufferSharedPtr *) 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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","indexBuffer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp2);
  if (arg1) (arg1)->indexBuffer = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_indexBuffer_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareIndexBufferSharedPtr *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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  result = (Ogre::HardwareIndexBufferSharedPtr *)& ((arg1)->indexBuffer);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_indexStart_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","indexStart", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->indexStart = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_indexStart_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  result =  ((arg1)->indexStart);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_indexCount_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","indexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->indexCount = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_indexCount_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  result =  ((arg1)->indexCount);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::IndexData.clone

  call-seq:
    clone(copyData=true, mgr=0) -> IndexData
    clone(copyData=true) -> IndexData
    clone -> IndexData

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_IndexData_clone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 0 ;
  bool arg2 ;
  Ogre::HardwareBufferManagerBase *arg3 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::IndexData *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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","clone", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","clone", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp3);
  result = (Ogre::IndexData *)((Ogre::IndexData const *)arg1)->clone(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_clone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::IndexData *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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","clone", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::IndexData *)((Ogre::IndexData const *)arg1)->clone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_clone__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IndexData *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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  result = (Ogre::IndexData *)((Ogre::IndexData const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IndexData_clone(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_Ogre__IndexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IndexData_clone__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__IndexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_IndexData_clone__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__IndexData, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IndexData_clone__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "IndexData.clone", 
    "    Ogre::IndexData * IndexData.clone(bool copyData, Ogre::HardwareBufferManagerBase *mgr)\n"
    "    Ogre::IndexData * IndexData.clone(bool copyData)\n"
    "    Ogre::IndexData * IndexData.clone()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IndexData_optimiseVertexCacheTriList(int argc, VALUE *argv, VALUE self) {
  Ogre::IndexData *arg1 = (Ogre::IndexData *) 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_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IndexData *","optimiseVertexCacheTriList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IndexData * >(argp1);
  (arg1)->optimiseVertexCacheTriList();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassVertexCacheProfiler;

SWIGINTERN VALUE
_wrap_new_VertexCacheProfiler__SWIG_0(int argc, VALUE *argv, VALUE self) {
  unsigned int arg1 ;
  Ogre::VertexCacheProfiler::CacheType arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexCacheProfiler";
  Ogre::VertexCacheProfiler *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Ogre::VertexCacheProfiler", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned int >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexCacheProfiler::CacheType","Ogre::VertexCacheProfiler", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::VertexCacheProfiler::CacheType >(val2);
  result = (Ogre::VertexCacheProfiler *)new Ogre::VertexCacheProfiler(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_VertexCacheProfiler__SWIG_1(int argc, VALUE *argv, VALUE self) {
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VertexCacheProfiler";
  Ogre::VertexCacheProfiler *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Ogre::VertexCacheProfiler", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (Ogre::VertexCacheProfiler *)new Ogre::VertexCacheProfiler(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VertexCacheProfiler__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::VertexCacheProfiler";
  Ogre::VertexCacheProfiler *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VertexCacheProfiler *)new Ogre::VertexCacheProfiler();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_VertexCacheProfiler(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_VertexCacheProfiler__SWIG_2(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_VertexCacheProfiler__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(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_VertexCacheProfiler__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "VertexCacheProfiler.new", 
    "    VertexCacheProfiler.new(unsigned int cachesize, Ogre::VertexCacheProfiler::CacheType cachetype)\n"
    "    VertexCacheProfiler.new(unsigned int cachesize)\n"
    "    VertexCacheProfiler.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_VertexCacheProfiler(Ogre::VertexCacheProfiler *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_VertexCacheProfiler_profile(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexCacheProfiler *arg1 = (Ogre::VertexCacheProfiler *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *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_Ogre__VertexCacheProfiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexCacheProfiler *","profile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexCacheProfiler * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr const &","profile", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareIndexBufferSharedPtr const &","profile", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp2);
  (arg1)->profile((Ogre::HardwareIndexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexCacheProfiler_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexCacheProfiler *arg1 = (Ogre::VertexCacheProfiler *) 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_Ogre__VertexCacheProfiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexCacheProfiler *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexCacheProfiler * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexCacheProfiler_flush(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexCacheProfiler *arg1 = (Ogre::VertexCacheProfiler *) 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_Ogre__VertexCacheProfiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexCacheProfiler *","flush", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexCacheProfiler * >(argp1);
  (arg1)->flush();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexCacheProfiler_getHits(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexCacheProfiler *arg1 = (Ogre::VertexCacheProfiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__VertexCacheProfiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexCacheProfiler *","getHits", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexCacheProfiler * >(argp1);
  result = (unsigned int)(arg1)->getHits();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexCacheProfiler_getMisses(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexCacheProfiler *arg1 = (Ogre::VertexCacheProfiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__VertexCacheProfiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexCacheProfiler *","getMisses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexCacheProfiler * >(argp1);
  result = (unsigned int)(arg1)->getMisses();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VertexCacheProfiler_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexCacheProfiler *arg1 = (Ogre::VertexCacheProfiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__VertexCacheProfiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexCacheProfiler *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexCacheProfiler * >(argp1);
  result = (unsigned int)(arg1)->getSize();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRenderOperation;

SWIGINTERN VALUE
_wrap_RenderOperation_vertexData_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","vertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  if (arg1) (arg1)->vertexData = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_vertexData_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","vertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  result = (Ogre::VertexData *) ((arg1)->vertexData);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_operationType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  Ogre::RenderOperation::OperationType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","operationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::RenderOperation::OperationType","operationType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::RenderOperation::OperationType >(val2);
  if (arg1) (arg1)->operationType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_operationType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderOperation::OperationType 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","operationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  result = (Ogre::RenderOperation::OperationType) ((arg1)->operationType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_useIndexes_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","useIndexes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","useIndexes", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->useIndexes = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_useIndexes_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","useIndexes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  result = (bool) ((arg1)->useIndexes);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_indexData_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  Ogre::IndexData *arg2 = (Ogre::IndexData *) 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","indexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IndexData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IndexData * >(argp2);
  if (arg1) (arg1)->indexData = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_indexData_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IndexData *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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","indexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  result = (Ogre::IndexData *) ((arg1)->indexData);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_srcRenderable_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","srcRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable const *","srcRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  if (arg1) (arg1)->srcRenderable = (Ogre::Renderable const *)arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_srcRenderable_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Renderable *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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","srcRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  result = (Ogre::Renderable *) ((arg1)->srcRenderable);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_numberOfInstances_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","numberOfInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","numberOfInstances", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->numberOfInstances = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_numberOfInstances_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","numberOfInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  result =  ((arg1)->numberOfInstances);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_useGlobalInstancingVertexBufferIsAvailable_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","useGlobalInstancingVertexBufferIsAvailable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","useGlobalInstancingVertexBufferIsAvailable", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->useGlobalInstancingVertexBufferIsAvailable = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderOperation_useGlobalInstancingVertexBufferIsAvailable_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderOperation *arg1 = (Ogre::RenderOperation *) 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_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","useGlobalInstancingVertexBufferIsAvailable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderOperation * >(argp1);
  result = (bool) ((arg1)->useGlobalInstancingVertexBufferIsAvailable);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderOperation(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderOperation";
  Ogre::RenderOperation *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderOperation *)new Ogre::RenderOperation();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderOperation(Ogre::RenderOperation *arg1) {
    delete arg1;
}

swig_class SwigClassLayerBlendModeEx;

SWIGINTERN VALUE
_wrap_LayerBlendModeEx_blendType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::LayerBlendType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","blendType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendType","blendType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendType >(val2);
  if (arg1) (arg1)->blendType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_blendType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LayerBlendType 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","blendType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::LayerBlendType) ((arg1)->blendType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_operation_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","operation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","operation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  if (arg1) (arg1)->operation = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_operation_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LayerBlendOperationEx 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","operation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::LayerBlendOperationEx) ((arg1)->operation);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_source1_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::LayerBlendSource arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","source1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","source1", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendSource >(val2);
  if (arg1) (arg1)->source1 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_source1_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LayerBlendSource 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","source1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::LayerBlendSource) ((arg1)->source1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_source2_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::LayerBlendSource arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","source2", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","source2", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendSource >(val2);
  if (arg1) (arg1)->source2 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_source2_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LayerBlendSource 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","source2", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::LayerBlendSource) ((arg1)->source2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_colourArg1_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::ColourValue *arg2 = (Ogre::ColourValue *) 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","colourArg1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue *","colourArg1", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  if (arg1) (arg1)->colourArg1 = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_colourArg1_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","colourArg1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::ColourValue *)& ((arg1)->colourArg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_colourArg2_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::ColourValue *arg2 = (Ogre::ColourValue *) 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","colourArg2", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue *","colourArg2", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  if (arg1) (arg1)->colourArg2 = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_colourArg2_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","colourArg2", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::ColourValue *)& ((arg1)->colourArg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_alphaArg1_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","alphaArg1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","alphaArg1", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->alphaArg1 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_alphaArg1_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","alphaArg1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::Real) ((arg1)->alphaArg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_alphaArg2_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","alphaArg2", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","alphaArg2", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->alphaArg2 = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_alphaArg2_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","alphaArg2", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::Real) ((arg1)->alphaArg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_factor_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","factor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","factor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->factor = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LayerBlendModeEx_factor_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx *","factor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  result = (Ogre::Real) ((arg1)->factor);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::LayerBlendModeEx.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_LayerBlendModeEx___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::LayerBlendModeEx *arg1 = (Ogre::LayerBlendModeEx *) 0 ;
  Ogre::LayerBlendModeEx *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_Ogre__LayerBlendModeEx, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__LayerBlendModeEx,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LayerBlendModeEx const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp2);
  result = (bool)((Ogre::LayerBlendModeEx const *)arg1)->operator ==((Ogre::LayerBlendModeEx const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_LayerBlendModeEx(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::LayerBlendModeEx";
  Ogre::LayerBlendModeEx *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LayerBlendModeEx *)new Ogre::LayerBlendModeEx();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LayerBlendModeEx(Ogre::LayerBlendModeEx *arg1) {
    delete arg1;
}

swig_class SwigClassMaterialSharedPtr;

SWIGINTERN VALUE
_wrap_new_MaterialSharedPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MaterialSharedPtr";
  Ogre::SharedPtr< Ogre::Material > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SharedPtr< Ogre::Material > *)new Ogre::SharedPtr< Ogre::Material >();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MaterialSharedPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MaterialSharedPtr";
  Ogre::SharedPtr< Ogre::Material > *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__SharedPtrT_Ogre__Material_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const &","Ogre::SharedPtr<(Ogre::Material)>", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SharedPtr< Ogre::Material > const &","Ogre::SharedPtr<(Ogre::Material)>", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::SharedPtr< Ogre::Material > *)new Ogre::SharedPtr< Ogre::Material >((Ogre::SharedPtr< Ogre::Material > const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaterialSharedPtr(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_MaterialSharedPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaterialSharedPtr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaterialSharedPtr.new", 
    "    MaterialSharedPtr.new()\n"
    "    MaterialSharedPtr.new(Ogre::SharedPtr< Ogre::Material > const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_SharedPtr_Sl_Ogre_Material_Sg_(Ogre::SharedPtr< Ogre::Material > *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MaterialSharedPtr___ref__(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Material *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::Material *) &((Ogre::SharedPtr< Ogre::Material > const *)arg1)->operator *();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr___deref__(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Material *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","operator ->", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::Material *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->operator ->();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Material *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::Material *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->get();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_bind__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Material *arg2 = (Ogre::Material *) 0 ;
  Ogre::SharedPtrFreeMethod arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","bind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Material *","bind", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Material * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SharedPtrFreeMethod","bind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SharedPtrFreeMethod >(val3);
  (arg1)->bind(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_bind__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Material *arg2 = (Ogre::Material *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","bind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Material *","bind", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Material * >(argp2);
  (arg1)->bind(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_bind(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Material, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialSharedPtr_bind__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Material, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSharedPtr_bind__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialSharedPtr.bind", 
    "    void MaterialSharedPtr.bind(Ogre::Material *rep, Ogre::SharedPtrFreeMethod inFreeMethod)\n"
    "    void MaterialSharedPtr.bind(Ogre::Material *rep)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_unique(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","unique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->unique();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_useCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","useCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (unsigned int)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->useCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_useCountPointer(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","useCountPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (unsigned int *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->useCountPointer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getPointer(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Material *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::Material *)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->getPointer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_freeMethod(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SharedPtrFreeMethod 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","freeMethod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::SharedPtrFreeMethod)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->freeMethod();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isNull(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)((Ogre::SharedPtr< Ogre::Material > const *)arg1)->isNull();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setNull(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (arg1)->setNull();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isTransparent(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isTransparent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->isTransparent();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setReceiveShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setReceiveShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setReceiveShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setReceiveShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getReceiveShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getReceiveShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->getReceiveShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setTransparencyCastsShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setTransparencyCastsShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTransparencyCastsShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setTransparencyCastsShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getTransparencyCastsShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getTransparencyCastsShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->getTransparencyCastsShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_createTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","createTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::Technique *)(*arg1)->createTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getTechnique__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Technique *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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","getTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Technique *)(*arg1)->getTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getTechnique__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Technique *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","getTechnique", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTechnique", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Technique *)(*arg1)->getTechnique((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_getTechnique(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_getTechnique__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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_MaterialSharedPtr_getTechnique__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.getTechnique", 
    "    Ogre::Technique * Material.getTechnique(unsigned short index)\n"
    "    Ogre::Technique * Material.getTechnique(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getNumTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getNumTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (unsigned short)(*arg1)->getNumTechniques();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_removeTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","removeTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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","removeTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (*arg1)->removeTechnique(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_removeAllTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","removeAllTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->removeAllTechniques();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getTechniqueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::Technique *,Ogre::STLAllocator< Ogre::Technique *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getTechniqueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (*arg1)->getTechniqueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::TechniqueIterator(static_cast< const Ogre::Material::TechniqueIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getSupportedTechniqueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::Technique *,Ogre::STLAllocator< Ogre::Technique *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getSupportedTechniqueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (*arg1)->getSupportedTechniqueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::TechniqueIterator(static_cast< const Ogre::Material::TechniqueIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getSupportedTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Technique *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getSupportedTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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","getSupportedTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Technique *)(*arg1)->getSupportedTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getNumSupportedTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getNumSupportedTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (unsigned short)(*arg1)->getNumSupportedTechniques();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getUnsupportedTechniquesExplanation(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getUnsupportedTechniquesExplanation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getUnsupportedTechniquesExplanation();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getNumLodLevels__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getNumLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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","getNumLodLevels", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (unsigned short)(*arg1)->getNumLodLevels(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getNumLodLevels__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getNumLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","getNumLodLevels", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumLodLevels", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (unsigned short)(*arg1)->getNumLodLevels((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_getNumLodLevels(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_getNumLodLevels__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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_MaterialSharedPtr_getNumLodLevels__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.getNumLodLevels", 
    "    unsigned short Material.getNumLodLevels(unsigned short schemeIndex)\n"
    "    unsigned short Material.getNumLodLevels(Ogre::String const &schemeName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getBestTechnique__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  unsigned short arg2 ;
  Ogre::Renderable *arg3 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Technique *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getBestTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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","getBestTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getBestTechnique", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Renderable * >(argp3);
  result = (Ogre::Technique *)(*arg1)->getBestTechnique(arg2,(Ogre::Renderable const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getBestTechnique__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Technique *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getBestTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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","getBestTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Technique *)(*arg1)->getBestTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getBestTechnique__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getBestTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::Technique *)(*arg1)->getBestTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_getBestTechnique(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MaterialSharedPtr_getBestTechnique__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_getBestTechnique__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MaterialSharedPtr_getBestTechnique__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.getBestTechnique", 
    "    Ogre::Technique * Material.getBestTechnique(unsigned short lodIndex, Ogre::Renderable const *rend)\n"
    "    Ogre::Technique * Material.getBestTechnique(unsigned short lodIndex)\n"
    "    Ogre::Technique * Material.getBestTechnique()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Material.clone

  call-seq:
    clone(newName, changeGroup=false, newGroup=BLANK) -> MaterialPtr
    clone(newName, changeGroup=false) -> MaterialPtr
    clone(newName) -> MaterialPtr

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_MaterialSharedPtr_clone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::MaterialPtr 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","clone", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","clone", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (*arg1)->clone((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_clone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::MaterialPtr 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","clone", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (*arg1)->clone((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_clone__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MaterialPtr 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (*arg1)->clone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_clone(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_Ogre__SharedPtrT_Ogre__Material_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_MaterialSharedPtr_clone__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSharedPtr_clone__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MaterialSharedPtr_clone__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.clone", 
    "    Ogre::MaterialPtr Material.clone(Ogre::String const &newName, bool changeGroup, Ogre::String const &newGroup)\n"
    "    Ogre::MaterialPtr Material.clone(Ogre::String const &newName, bool changeGroup)\n"
    "    Ogre::MaterialPtr Material.clone(Ogre::String const &newName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_copyDetailsTo(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::MaterialPtr *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","copyDetailsTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr &","copyDetailsTo", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr &","copyDetailsTo", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (*arg1)->copyDetailsTo(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_compile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","compile", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->compile(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_compile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->compile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_compile(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MaterialSharedPtr_compile__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_compile__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.compile", 
    "    void Material.compile(bool autoManageTextureUnits)\n"
    "    void Material.compile()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setPointSize(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setPointSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPointSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (*arg1)->setPointSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setAmbient__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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 ;
  
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setAmbient", 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","setAmbient", 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","setAmbient", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (*arg1)->setAmbient(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setAmbient__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::ColourValue *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setAmbient", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setAmbient", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (*arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_setAmbient(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialSharedPtr_setAmbient__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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_MaterialSharedPtr_setAmbient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.setAmbient", 
    "    void Material.setAmbient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.setAmbient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setDiffuse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDiffuse", 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","setDiffuse", 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","setDiffuse", 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","setDiffuse", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (*arg1)->setDiffuse(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setDiffuse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::ColourValue *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setDiffuse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setDiffuse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (*arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_setDiffuse(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialSharedPtr_setDiffuse__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_MaterialSharedPtr_setDiffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.setDiffuse", 
    "    void Material.setDiffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.setDiffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSpecular__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpecular", 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","setSpecular", 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","setSpecular", 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","setSpecular", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (*arg1)->setSpecular(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSpecular__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::ColourValue *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSpecular", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSpecular", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (*arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_setSpecular(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialSharedPtr_setSpecular__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_MaterialSharedPtr_setSpecular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.setSpecular", 
    "    void Material.setSpecular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.setSpecular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setShininess(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setShininess", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShininess", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (*arg1)->setShininess(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSelfIllumination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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 ;
  
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSelfIllumination", 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","setSelfIllumination", 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","setSelfIllumination", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (*arg1)->setSelfIllumination(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSelfIllumination__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::ColourValue *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (*arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_setSelfIllumination(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialSharedPtr_setSelfIllumination__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_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_MaterialSharedPtr_setSelfIllumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.setSelfIllumination", 
    "    void Material.setSelfIllumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.setSelfIllumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setDepthCheckEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setDepthCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthCheckEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setDepthCheckEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setDepthWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setDepthWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setDepthWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setDepthFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setDepthFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setDepthFunction", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (*arg1)->setDepthFunction(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setColourWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setColourWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setColourWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setColourWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::CullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CullingMode","setCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CullingMode >(val2);
  (*arg1)->setCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setManualCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::ManualCullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setManualCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ManualCullingMode","setManualCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ManualCullingMode >(val2);
  (*arg1)->setManualCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setLightingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setLightingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLightingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setLightingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setShadingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::ShadeOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setShadingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadeOptions","setShadingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadeOptions >(val2);
  (*arg1)->setShadingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setFog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setFog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setFog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setFog__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  (*arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setFog__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  (*arg1)->setFog(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setFog__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setFog(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_setFog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_setFog__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_MaterialSharedPtr_setFog__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MaterialSharedPtr_setFog__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_MaterialSharedPtr_setFog__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_MaterialSharedPtr_setFog__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MaterialSharedPtr_setFog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Material.setFog", 
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Material.setFog(bool overrideScene)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setDepthBias(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setDepthBias", 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","setDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (*arg1)->setDepthBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setTextureFiltering(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::TextureFilterOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureFilterOptions","setTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureFilterOptions >(val2);
  (*arg1)->setTextureFiltering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setTextureAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setTextureAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setTextureAnisotropy", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (*arg1)->setTextureAnisotropy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::SceneBlendType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  (*arg1)->setSceneBlending(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  (*arg1)->setSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_setSceneBlending(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_setSceneBlending__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _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_MaterialSharedPtr_setSceneBlending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.setSceneBlending", 
    "    void Material.setSceneBlending(Ogre::SceneBlendType const sbt)\n"
    "    void Material.setSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSeparateSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::SceneBlendType arg2 ;
  Ogre::SceneBlendType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendType >(val3);
  (*arg1)->setSeparateSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setSeparateSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendFactor arg4 ;
  Ogre::SceneBlendFactor arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendFactor >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::SceneBlendFactor >(val5);
  (*arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_setSeparateSceneBlending(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _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_MaterialSharedPtr_setSeparateSceneBlending__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _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) {
          {
            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_MaterialSharedPtr_setSeparateSceneBlending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.setSeparateSceneBlending", 
    "    void Material.setSeparateSceneBlending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Material.setSeparateSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr__notifyNeedsRecompile(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","_notifyNeedsRecompile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->_notifyNeedsRecompile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Material::LodValueList *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Material::LodValueList const &","setLodLevels", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Material::LodValueList const &","setLodLevels", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Material::LodValueList * >(argp2);
  (*arg1)->setLodLevels((Ogre::Material::LodValueList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getLodValueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getLodValueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (*arg1)->getLodValueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::LodValueIterator(static_cast< const Ogre::Material::LodValueIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getUserLodValueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getUserLodValueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (*arg1)->getUserLodValueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::LodValueIterator(static_cast< const Ogre::Material::LodValueIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getLodIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::ushort 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::ushort)(*arg1)->getLodIndex(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LodStrategy *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::LodStrategy *)(*arg1)->getLodStrategy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::LodStrategy *arg2 = (Ogre::LodStrategy *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodStrategy *","setLodStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodStrategy * >(argp2);
  (*arg1)->setLodStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_touch(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","touch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->touch();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_applyTextureAliases__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","applyTextureAliases", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(*arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_applyTextureAliases__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::AliasTextureNamePairList *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  result = (bool)(*arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_applyTextureAliases(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialSharedPtr_applyTextureAliases__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSharedPtr_applyTextureAliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.applyTextureAliases", 
    "    bool Material.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Material.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getCompilationRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getCompilationRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->getCompilationRequired();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_cast(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  VALUE arg2 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Material *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","cast", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  arg2 = argv[0];
  result = (Ogre::Material *)Ogre_Material_cast(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","prepare", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->prepare(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_prepare(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MaterialSharedPtr_prepare__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_prepare__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.prepare", 
    "    void Resource.prepare(bool backgroundThread)\n"
    "    void Resource.prepare()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","load", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->load(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_load(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MaterialSharedPtr_load__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSharedPtr_load__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.load", 
    "    void Resource.load(bool backgroundThread)\n"
    "    void Resource.load()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_reload(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","reload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->reload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isReloadable(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isReloadable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->isReloadable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isManuallyLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isManuallyLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->isManuallyLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (*arg1)->getSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceHandle 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::ResourceHandle)(*arg1)->getHandle();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isPrepared(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isPrepared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->isPrepared();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->isLoading();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getLoadingState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource::LoadingState 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getLoadingState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::Resource::LoadingState)(*arg1)->getLoadingState();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_isBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","isBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (bool)(*arg1)->isBackgroundLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBackgroundLoaded", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setBackgroundLoaded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_escalateLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","escalateLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->escalateLoading();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (*arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (*arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_changeGroupOwnership(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","changeGroupOwnership", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","changeGroupOwnership", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","changeGroupOwnership", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getCreator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceManager *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getCreator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::ResourceManager *)(*arg1)->getCreator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getOrigin();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr__notifyOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","_notifyOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","_notifyOrigin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyOrigin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->_notifyOrigin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getStateCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getStateCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (*arg1)->getStateCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr__dirtyState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","_dirtyState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->_dirtyState();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr__fireLoadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","_fireLoadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_fireLoadingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->_fireLoadingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr__firePreparingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","_firePreparingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_firePreparingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->_firePreparingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr__fireUnloadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","_fireUnloadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->_fireUnloadingComplete();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getParamDictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getParamDictionary__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSharedPtr_getParamDictionary(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_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MaterialSharedPtr_getParamDictionary__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MaterialSharedPtr_getParamDictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.getParamDictionary", 
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParameterList *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  result = (Ogre::ParameterList *) &(*arg1)->getParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_setParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","setParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 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 &","setParameter", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)(*arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  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_MaterialSharedPtr_setParameterList(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::NameValuePairList *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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","setParameterList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::NameValuePairList * >(argp2);
  (*arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_getParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","getParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(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( "", "Ogre::String const &","getParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getParameter", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (*arg1)->getParameter((Ogre::String const &)*arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_copyParametersTo(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 0 ;
  Ogre::StringInterface *arg2 = (Ogre::StringInterface *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > const *","copyParametersTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringInterface *","copyParametersTo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::StringInterface * >(argp2);
  (*arg1)->copyParametersTo(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSharedPtr_cleanupDictionary(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Material > *arg1 = (Ogre::SharedPtr< Ogre::Material > *) 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_Ogre__SharedPtrT_Ogre__Material_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Material > *","cleanupDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Material > * >(argp1);
  (*arg1)->cleanupDictionary();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMaterial;

SWIGINTERN VALUE
_wrap_new_Material__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Material";
  Ogre::Material *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Material", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Material", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Material", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Material", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Material", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Material", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Material", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","Ogre::Material", 6, argv[5] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::Material *)new Ogre::Material(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Material__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Material";
  Ogre::Material *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Material", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Material", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Material", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Material", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Material", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Material", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Material", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::Material *)new Ogre::Material(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Material__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Material";
  Ogre::Material *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Material", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Material", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Material", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Material", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Material", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Material", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::Material *)new Ogre::Material(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Material(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Material__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Material__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Material__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.new", 
    "    Material.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Material.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual)\n"
    "    Material.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Material(Ogre::Material *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Material_isTransparent(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","isTransparent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (bool)((Ogre::Material const *)arg1)->isTransparent();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setReceiveShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setReceiveShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setReceiveShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setReceiveShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getReceiveShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getReceiveShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (bool)((Ogre::Material const *)arg1)->getReceiveShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setTransparencyCastsShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setTransparencyCastsShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTransparencyCastsShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTransparencyCastsShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getTransparencyCastsShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getTransparencyCastsShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (bool)((Ogre::Material const *)arg1)->getTransparencyCastsShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_createTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","createTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (Ogre::Technique *)(arg1)->createTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getTechnique__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Technique *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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","getTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Technique *)(arg1)->getTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getTechnique__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Technique *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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( "", "Ogre::String const &","getTechnique", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTechnique", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Technique *)(arg1)->getTechnique((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_getTechnique(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Material_getTechnique__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_Material_getTechnique__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.getTechnique", 
    "    Ogre::Technique * Material.getTechnique(unsigned short index)\n"
    "    Ogre::Technique * Material.getTechnique(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getNumTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getNumTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (unsigned short)((Ogre::Material const *)arg1)->getNumTechniques();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_removeTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","removeTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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","removeTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removeTechnique(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_removeAllTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","removeAllTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  (arg1)->removeAllTechniques();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getTechniqueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::Technique *,Ogre::STLAllocator< Ogre::Technique *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getTechniqueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (arg1)->getTechniqueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::TechniqueIterator(static_cast< const Ogre::Material::TechniqueIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getSupportedTechniqueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::Technique *,Ogre::STLAllocator< Ogre::Technique *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getSupportedTechniqueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (arg1)->getSupportedTechniqueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::TechniqueIterator(static_cast< const Ogre::Material::TechniqueIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getSupportedTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Technique *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getSupportedTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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","getSupportedTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Technique *)(arg1)->getSupportedTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getNumSupportedTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getNumSupportedTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (unsigned short)((Ogre::Material const *)arg1)->getNumSupportedTechniques();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getUnsupportedTechniquesExplanation(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getUnsupportedTechniquesExplanation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (Ogre::String *) &((Ogre::Material const *)arg1)->getUnsupportedTechniquesExplanation();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getNumLodLevels__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getNumLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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","getNumLodLevels", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (unsigned short)((Ogre::Material const *)arg1)->getNumLodLevels(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getNumLodLevels__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned short 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getNumLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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( "", "Ogre::String const &","getNumLodLevels", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumLodLevels", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (unsigned short)((Ogre::Material const *)arg1)->getNumLodLevels((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_getNumLodLevels(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Material_getNumLodLevels__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_Material_getNumLodLevels__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.getNumLodLevels", 
    "    unsigned short Material.getNumLodLevels(unsigned short schemeIndex)\n"
    "    unsigned short Material.getNumLodLevels(Ogre::String const &schemeName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getBestTechnique__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  unsigned short arg2 ;
  Ogre::Renderable *arg3 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Technique *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getBestTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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","getBestTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getBestTechnique", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Renderable * >(argp3);
  result = (Ogre::Technique *)(arg1)->getBestTechnique(arg2,(Ogre::Renderable const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getBestTechnique__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Technique *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getBestTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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","getBestTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Technique *)(arg1)->getBestTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getBestTechnique__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","getBestTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (Ogre::Technique *)(arg1)->getBestTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_getBestTechnique(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Material_getBestTechnique__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Material_getBestTechnique__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Material_getBestTechnique__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.getBestTechnique", 
    "    Ogre::Technique * Material.getBestTechnique(unsigned short lodIndex, Ogre::Renderable const *rend)\n"
    "    Ogre::Technique * Material.getBestTechnique(unsigned short lodIndex)\n"
    "    Ogre::Technique * Material.getBestTechnique()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_clone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::MaterialPtr 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","clone", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","clone", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = ((Ogre::Material const *)arg1)->clone((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_clone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::MaterialPtr 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","clone", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = ((Ogre::Material const *)arg1)->clone((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_clone__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MaterialPtr 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::Material const *)arg1)->clone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_clone(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_Ogre__Material, 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_Material_clone__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Material_clone__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Material_clone__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.clone", 
    "    Ogre::MaterialPtr Material.clone(Ogre::String const &newName, bool changeGroup, Ogre::String const &newGroup)\n"
    "    Ogre::MaterialPtr Material.clone(Ogre::String const &newName, bool changeGroup)\n"
    "    Ogre::MaterialPtr Material.clone(Ogre::String const &newName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_copyDetailsTo(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::MaterialPtr *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","copyDetailsTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr &","copyDetailsTo", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr &","copyDetailsTo", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  ((Ogre::Material const *)arg1)->copyDetailsTo(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_compile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","compile", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->compile(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_compile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  (arg1)->compile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_compile(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Material_compile__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Material_compile__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Material.compile", 
    "    void Material.compile(bool autoManageTextureUnits)\n"
    "    void Material.compile()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setPointSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setPointSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPointSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setPointSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setAmbient__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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 ;
  
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setAmbient", 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","setAmbient", 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","setAmbient", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setAmbient(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setAmbient__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::ColourValue *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setAmbient", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setAmbient", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_setAmbient(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Material_setAmbient__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_Material_setAmbient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.setAmbient", 
    "    void Material.setAmbient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.setAmbient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setDiffuse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDiffuse", 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","setDiffuse", 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","setDiffuse", 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","setDiffuse", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setDiffuse(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setDiffuse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::ColourValue *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setDiffuse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setDiffuse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_setDiffuse(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Material_setDiffuse__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Material_setDiffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.setDiffuse", 
    "    void Material.setDiffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.setDiffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSpecular__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpecular", 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","setSpecular", 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","setSpecular", 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","setSpecular", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setSpecular(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSpecular__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::ColourValue *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSpecular", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSpecular", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_setSpecular(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Material_setSpecular__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Material_setSpecular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.setSpecular", 
    "    void Material.setSpecular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Material.setSpecular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setShininess(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setShininess", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShininess", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShininess(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSelfIllumination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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 ;
  
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSelfIllumination", 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","setSelfIllumination", 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","setSelfIllumination", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setSelfIllumination(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSelfIllumination__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::ColourValue *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_setSelfIllumination(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Material_setSelfIllumination__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 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_Material_setSelfIllumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Material.setSelfIllumination", 
    "    void Material.setSelfIllumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Material.setSelfIllumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setDepthCheckEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setDepthCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthCheckEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDepthCheckEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setDepthWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setDepthWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDepthWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setDepthFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setDepthFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setDepthFunction", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (arg1)->setDepthFunction(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setColourWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setColourWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setColourWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setColourWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::CullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CullingMode","setCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CullingMode >(val2);
  (arg1)->setCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setManualCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::ManualCullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setManualCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ManualCullingMode","setManualCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ManualCullingMode >(val2);
  (arg1)->setManualCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setLightingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setLightingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLightingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLightingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setShadingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::ShadeOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setShadingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadeOptions","setShadingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadeOptions >(val2);
  (arg1)->setShadingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setFog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setFog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setFog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setFog__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setFog__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  (arg1)->setFog(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setFog__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFog(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_setFog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Material_setFog__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Material_setFog__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Material_setFog__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Material_setFog__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Material_setFog__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Material_setFog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Material.setFog", 
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Material.setFog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Material.setFog(bool overrideScene)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setDepthBias(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setDepthBias", 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","setDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setDepthBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setTextureFiltering(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::TextureFilterOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureFilterOptions","setTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureFilterOptions >(val2);
  (arg1)->setTextureFiltering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setTextureAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setTextureAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setTextureAnisotropy", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setTextureAnisotropy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::SceneBlendType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  (arg1)->setSceneBlending(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSeparateSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::SceneBlendType arg2 ;
  Ogre::SceneBlendType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendType >(val3);
  (arg1)->setSeparateSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  (arg1)->setSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_setSceneBlending(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Material_setSceneBlending__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _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_Material_setSceneBlending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.setSceneBlending", 
    "    void Material.setSceneBlending(Ogre::SceneBlendType const sbt)\n"
    "    void Material.setSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setSeparateSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendFactor arg4 ;
  Ogre::SceneBlendFactor arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendFactor >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::SceneBlendFactor >(val5);
  (arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_setSeparateSceneBlending(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_Ogre__Material, 0);
    _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_Material_setSeparateSceneBlending__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _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) {
          {
            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_Material_setSeparateSceneBlending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Material.setSeparateSceneBlending", 
    "    void Material.setSeparateSceneBlending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Material.setSeparateSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material__notifyNeedsRecompile(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","_notifyNeedsRecompile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  (arg1)->_notifyNeedsRecompile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::Material::LodValueList *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Material::LodValueList const &","setLodLevels", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Material::LodValueList const &","setLodLevels", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Material::LodValueList * >(argp2);
  (arg1)->setLodLevels((Ogre::Material::LodValueList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getLodValueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getLodValueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = ((Ogre::Material const *)arg1)->getLodValueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::LodValueIterator(static_cast< const Ogre::Material::LodValueIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getUserLodValueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getUserLodValueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = ((Ogre::Material const *)arg1)->getUserLodValueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Material::LodValueIterator(static_cast< const Ogre::Material::LodValueIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getLodIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::ushort 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::ushort)((Ogre::Material const *)arg1)->getLodIndex(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LodStrategy *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (Ogre::LodStrategy *)((Ogre::Material const *)arg1)->getLodStrategy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_setLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::LodStrategy *arg2 = (Ogre::LodStrategy *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","setLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodStrategy *","setLodStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodStrategy * >(argp2);
  (arg1)->setLodStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_touch(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","touch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  (arg1)->touch();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_applyTextureAliases__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","applyTextureAliases", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)((Ogre::Material const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_applyTextureAliases__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::AliasTextureNamePairList *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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  result = (bool)((Ogre::Material const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Material_applyTextureAliases(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_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Material_applyTextureAliases__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Material_applyTextureAliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Material.applyTextureAliases", 
    "    bool Material.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Material.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_getCompilationRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 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_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material const *","getCompilationRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (bool)((Ogre::Material const *)arg1)->getCompilationRequired();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Material_cast(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  Ogre::Material *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (Ogre::Material *)Ogre_Material_cast(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMaterialPtr;

SWIGINTERN VALUE
_wrap_new_MaterialPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MaterialPtr";
  Ogre::MaterialPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MaterialPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MaterialPtr";
  Ogre::MaterialPtr *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__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","Ogre::MaterialPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MaterialPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MaterialPtr";
  Ogre::MaterialPtr *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__MaterialPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","Ogre::MaterialPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","Ogre::MaterialPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialPtr * >(argp1);
  result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr((Ogre::MaterialPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MaterialPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MaterialPtr";
  Ogre::MaterialPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::MaterialPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::MaterialPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::MaterialPtr *)new Ogre::MaterialPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MaterialPtr(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_MaterialPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaterialPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaterialPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MaterialPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MaterialPtr.new", 
    "    MaterialPtr.new()\n"
    "    MaterialPtr.new(Ogre::Material *rep)\n"
    "    MaterialPtr.new(Ogre::MaterialPtr const &r)\n"
    "    MaterialPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialPtr(Ogre::MaterialPtr *arg1) {
    delete arg1;
}

swig_class SwigClassSerializer;

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

SWIGINTERN VALUE
_wrap_new_Serializer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Serializer";
  Ogre::Serializer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Serializer *)new Ogre::Serializer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Serializer(Ogre::Serializer *arg1) {
    delete arg1;
}

swig_class SwigClassGpuConstantDefinition;

SWIGINTERN VALUE
_wrap_GpuConstantDefinition_constType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  Ogre::GpuConstantType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","constType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuConstantType","constType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuConstantType >(val2);
  if (arg1) (arg1)->constType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_constType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuConstantType 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","constType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result = (Ogre::GpuConstantType) ((arg1)->constType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_physicalIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","physicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","physicalIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->physicalIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_physicalIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","physicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result =  ((arg1)->physicalIndex);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_logicalIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","logicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","logicalIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->logicalIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_logicalIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","logicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result =  ((arg1)->logicalIndex);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_elementSize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","elementSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","elementSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->elementSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_elementSize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","elementSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result =  ((arg1)->elementSize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_arraySize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","arraySize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","arraySize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->arraySize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_arraySize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","arraySize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result =  ((arg1)->arraySize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_variability_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","variability", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","variability", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  if (arg1) (arg1)->variability = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_variability_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition *","variability", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result = (Ogre::uint16) ((arg1)->variability);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_isFloat__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition const *","isFloat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result = (bool)((Ogre::GpuConstantDefinition const *)arg1)->isFloat();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_isFloat__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::GpuConstantType","Ogre::GpuConstantDefinition::isFloat", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::GpuConstantType >(val1);
  result = (bool)Ogre::GpuConstantDefinition::isFloat(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuConstantDefinition_isFloat(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuConstantDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GpuConstantDefinition_isFloat__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_GpuConstantDefinition_isFloat__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuConstantDefinition.isFloat", 
    "    bool GpuConstantDefinition.isFloat(Ogre::GpuConstantDefinition const *self)\n"
    "    bool GpuConstantDefinition.isFloat(Ogre::GpuConstantType c)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_isSampler__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantDefinition *arg1 = (Ogre::GpuConstantDefinition *) 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_Ogre__GpuConstantDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition const *","isSampler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp1);
  result = (bool)((Ogre::GpuConstantDefinition const *)arg1)->isSampler();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_isSampler__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::GpuConstantType","Ogre::GpuConstantDefinition::isSampler", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::GpuConstantType >(val1);
  result = (bool)Ogre::GpuConstantDefinition::isSampler(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuConstantDefinition_isSampler(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuConstantDefinition, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_GpuConstantDefinition_isSampler__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_GpuConstantDefinition_isSampler__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuConstantDefinition.isSampler", 
    "    bool GpuConstantDefinition.isSampler(Ogre::GpuConstantDefinition const *self)\n"
    "    bool GpuConstantDefinition.isSampler(Ogre::GpuConstantType c)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuConstantDefinition_getElementSize(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuConstantType arg1 ;
  bool arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t 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( "", "Ogre::GpuConstantType","Ogre::GpuConstantDefinition::getElementSize", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::GpuConstantType >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::GpuConstantDefinition::getElementSize", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = Ogre::GpuConstantDefinition::getElementSize(arg1,arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_GpuConstantDefinition(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuConstantDefinition";
  Ogre::GpuConstantDefinition *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuConstantDefinition *)new Ogre::GpuConstantDefinition();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuConstantDefinition(Ogre::GpuConstantDefinition *arg1) {
    delete arg1;
}

swig_class SwigClassGpuNamedConstants;

SWIGINTERN VALUE
_wrap_GpuNamedConstants_floatBufferSize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","floatBufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","floatBufferSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->floatBufferSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_floatBufferSize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","floatBufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp1);
  result =  ((arg1)->floatBufferSize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_intBufferSize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","intBufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","intBufferSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->intBufferSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_intBufferSize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","intBufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp1);
  result =  ((arg1)->intBufferSize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_map_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 0 ;
  Ogre::GpuConstantDefinitionMap *arg2 = (Ogre::GpuConstantDefinitionMap *) 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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","map", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,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, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinitionMap *","map", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuConstantDefinitionMap * >(argp2);
  if (arg1) (arg1)->map = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_map_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuConstantDefinitionMap *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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","map", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp1);
  result = (Ogre::GpuConstantDefinitionMap *)& ((arg1)->map);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), 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, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_GpuNamedConstants(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuNamedConstants";
  Ogre::GpuNamedConstants *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuNamedConstants *)new Ogre::GpuNamedConstants();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_generateConstantDefinitionArrayEntries(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuConstantDefinition *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","generateConstantDefinitionArrayEntries", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(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( "", "Ogre::String const &","generateConstantDefinitionArrayEntries", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","generateConstantDefinitionArrayEntries", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__GpuConstantDefinition,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuConstantDefinition const &","generateConstantDefinitionArrayEntries", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuConstantDefinition const &","generateConstantDefinitionArrayEntries", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::GpuConstantDefinition * >(argp3);
  (arg1)->generateConstantDefinitionArrayEntries((Ogre::String const &)*arg2,(Ogre::GpuConstantDefinition const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_getGenerateAllConstantDefinitionArrayEntries(int argc, VALUE *argv, VALUE self) {
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (bool)Ogre::GpuNamedConstants::getGenerateAllConstantDefinitionArrayEntries();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_setGenerateAllConstantDefinitionArrayEntries(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::GpuNamedConstants::setGenerateAllConstantDefinitionArrayEntries", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  Ogre::GpuNamedConstants::setGenerateAllConstantDefinitionArrayEntries(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_save(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 0 ;
  Ogre::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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants const *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(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( "", "Ogre::String const &","save", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","save", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ((Ogre::GpuNamedConstants const *)arg1)->save((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstants_load(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstants *arg1 = (Ogre::GpuNamedConstants *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->load(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuNamedConstants(Ogre::GpuNamedConstants *arg1) {
    delete arg1;
}

swig_class SwigClassGpuNamedConstantsSerializer;

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

SWIGINTERN VALUE
_wrap_new_GpuNamedConstantsSerializer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuNamedConstantsSerializer";
  Ogre::GpuNamedConstantsSerializer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuNamedConstantsSerializer *)new Ogre::GpuNamedConstantsSerializer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuNamedConstantsSerializer(Ogre::GpuNamedConstantsSerializer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstantsSerializer *arg1 = (Ogre::GpuNamedConstantsSerializer *) 0 ;
  Ogre::GpuNamedConstants *arg2 = (Ogre::GpuNamedConstants *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Serializer::Endian arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuNamedConstantsSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstantsSerializer *","exportNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstantsSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants const *","exportNamedConstants", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp2);
  {
    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 &","exportNamedConstants", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportNamedConstants", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportNamedConstants", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Serializer::Endian >(val4);
  (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstantsSerializer *arg1 = (Ogre::GpuNamedConstantsSerializer *) 0 ;
  Ogre::GpuNamedConstants *arg2 = (Ogre::GpuNamedConstants *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__GpuNamedConstantsSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstantsSerializer *","exportNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstantsSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants const *","exportNamedConstants", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp2);
  {
    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 &","exportNamedConstants", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportNamedConstants", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstantsSerializer *arg1 = (Ogre::GpuNamedConstantsSerializer *) 0 ;
  Ogre::GpuNamedConstants *arg2 = (Ogre::GpuNamedConstants *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  Ogre::Serializer::Endian arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuNamedConstantsSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstantsSerializer *","exportNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstantsSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants const *","exportNamedConstants", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportNamedConstants", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportNamedConstants", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportNamedConstants", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Serializer::Endian >(val4);
  (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstantsSerializer *arg1 = (Ogre::GpuNamedConstantsSerializer *) 0 ;
  Ogre::GpuNamedConstants *arg2 = (Ogre::GpuNamedConstants *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__GpuNamedConstantsSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstantsSerializer *","exportNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstantsSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants const *","exportNamedConstants", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportNamedConstants", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportNamedConstants", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  (arg1)->exportNamedConstants((Ogre::GpuNamedConstants const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuNamedConstantsSerializer_exportNamedConstants(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_Ogre__GpuNamedConstantsSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__GpuNamedConstants, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuNamedConstantsSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__GpuNamedConstants, 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_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuNamedConstantsSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__GpuNamedConstants, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuNamedConstantsSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__GpuNamedConstants, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuNamedConstantsSerializer_exportNamedConstants__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuNamedConstantsSerializer.exportNamedConstants", 
    "    void GpuNamedConstantsSerializer.exportNamedConstants(Ogre::GpuNamedConstants const *pConsts, Ogre::String const &filename, Ogre::Serializer::Endian endianMode)\n"
    "    void GpuNamedConstantsSerializer.exportNamedConstants(Ogre::GpuNamedConstants const *pConsts, Ogre::String const &filename)\n"
    "    void GpuNamedConstantsSerializer.exportNamedConstants(Ogre::GpuNamedConstants const *pConsts, Ogre::DataStreamPtr stream, Ogre::Serializer::Endian endianMode)\n"
    "    void GpuNamedConstantsSerializer.exportNamedConstants(Ogre::GpuNamedConstants const *pConsts, Ogre::DataStreamPtr stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuNamedConstantsSerializer_importNamedConstants(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuNamedConstantsSerializer *arg1 = (Ogre::GpuNamedConstantsSerializer *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::GpuNamedConstants *arg3 = (Ogre::GpuNamedConstants *) 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_Ogre__GpuNamedConstantsSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstantsSerializer *","importNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuNamedConstantsSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","importNamedConstants", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","importNamedConstants", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants *","importNamedConstants", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp3);
  (arg1)->importNamedConstants(*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassGpuLogicalIndexUse;

SWIGINTERN VALUE
_wrap_GpuLogicalIndexUse_physicalIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalIndexUse *arg1 = (Ogre::GpuLogicalIndexUse *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuLogicalIndexUse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalIndexUse *","physicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalIndexUse * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","physicalIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->physicalIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalIndexUse_physicalIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalIndexUse *arg1 = (Ogre::GpuLogicalIndexUse *) 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_Ogre__GpuLogicalIndexUse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalIndexUse *","physicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalIndexUse * >(argp1);
  result =  ((arg1)->physicalIndex);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalIndexUse_currentSize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalIndexUse *arg1 = (Ogre::GpuLogicalIndexUse *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuLogicalIndexUse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalIndexUse *","currentSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalIndexUse * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","currentSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->currentSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalIndexUse_currentSize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalIndexUse *arg1 = (Ogre::GpuLogicalIndexUse *) 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_Ogre__GpuLogicalIndexUse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalIndexUse *","currentSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalIndexUse * >(argp1);
  result =  ((arg1)->currentSize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalIndexUse_variability_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalIndexUse *arg1 = (Ogre::GpuLogicalIndexUse *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__GpuLogicalIndexUse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalIndexUse *","variability", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalIndexUse * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","variability", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  if (arg1) (arg1)->variability = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalIndexUse_variability_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalIndexUse *arg1 = (Ogre::GpuLogicalIndexUse *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__GpuLogicalIndexUse, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalIndexUse *","variability", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalIndexUse * >(argp1);
  result = (Ogre::uint16) ((arg1)->variability);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_GpuLogicalIndexUse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuLogicalIndexUse";
  Ogre::GpuLogicalIndexUse *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuLogicalIndexUse *)new Ogre::GpuLogicalIndexUse();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_GpuLogicalIndexUse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  Ogre::uint16 arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuLogicalIndexUse";
  Ogre::GpuLogicalIndexUse *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::GpuLogicalIndexUse", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::GpuLogicalIndexUse", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::GpuLogicalIndexUse", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = (Ogre::GpuLogicalIndexUse *)new Ogre::GpuLogicalIndexUse(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_GpuLogicalIndexUse(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_GpuLogicalIndexUse__SWIG_0(nargs, args, self);
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_GpuLogicalIndexUse__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuLogicalIndexUse.new", 
    "    GpuLogicalIndexUse.new()\n"
    "    GpuLogicalIndexUse.new(size_t bufIdx, size_t curSz, Ogre::uint16 v)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuLogicalIndexUse(Ogre::GpuLogicalIndexUse *arg1) {
    delete arg1;
}

swig_class SwigClassGpuLogicalBufferStruct;

SWIGINTERN VALUE
_wrap_GpuLogicalBufferStruct_map_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalBufferStruct *arg1 = (Ogre::GpuLogicalBufferStruct *) 0 ;
  Ogre::GpuLogicalIndexUseMap *arg2 = (Ogre::GpuLogicalIndexUseMap *) 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_Ogre__GpuLogicalBufferStruct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalBufferStruct *","map", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalBufferStruct * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,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, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuLogicalIndexUseMap *","map", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuLogicalIndexUseMap * >(argp2);
  if (arg1) (arg1)->map = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalBufferStruct_map_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalBufferStruct *arg1 = (Ogre::GpuLogicalBufferStruct *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuLogicalIndexUseMap *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_Ogre__GpuLogicalBufferStruct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalBufferStruct *","map", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalBufferStruct * >(argp1);
  result = (Ogre::GpuLogicalIndexUseMap *)& ((arg1)->map);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), 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, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalBufferStruct_bufferSize_set(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalBufferStruct *arg1 = (Ogre::GpuLogicalBufferStruct *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuLogicalBufferStruct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalBufferStruct *","bufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalBufferStruct * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","bufferSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->bufferSize = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuLogicalBufferStruct_bufferSize_get(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuLogicalBufferStruct *arg1 = (Ogre::GpuLogicalBufferStruct *) 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_Ogre__GpuLogicalBufferStruct, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuLogicalBufferStruct *","bufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuLogicalBufferStruct * >(argp1);
  result =  ((arg1)->bufferSize);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_GpuLogicalBufferStruct(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuLogicalBufferStruct";
  Ogre::GpuLogicalBufferStruct *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuLogicalBufferStruct *)new Ogre::GpuLogicalBufferStruct();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuLogicalBufferStruct(Ogre::GpuLogicalBufferStruct *arg1) {
    delete arg1;
}

swig_class SwigClassGpuSharedParameters;

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

SWIGINTERN VALUE
_wrap_new_GpuSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::GpuSharedParameters";
  Ogre::GpuSharedParameters *result = 0 ;
  
  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 &","Ogre::GpuSharedParameters", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::GpuSharedParameters", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::GpuSharedParameters *)new Ogre::GpuSharedParameters((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuSharedParameters(Ogre::GpuSharedParameters *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_GpuSharedParameters_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  result = (Ogre::String *) &(arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_addConstantDefinition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuConstantType arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","addConstantDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","addConstantDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addConstantDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuConstantType","addConstantDefinition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuConstantType >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","addConstantDefinition", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->addConstantDefinition((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_addConstantDefinition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuConstantType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","addConstantDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","addConstantDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addConstantDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuConstantType","addConstantDefinition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuConstantType >(val3);
  (arg1)->addConstantDefinition((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_addConstantDefinition(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_Ogre__GpuSharedParameters, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuSharedParameters_addConstantDefinition__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuSharedParameters_addConstantDefinition__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuSharedParameters.addConstantDefinition", 
    "    void GpuSharedParameters.addConstantDefinition(Ogre::String const &name, Ogre::GpuConstantType constType, size_t arraySize)\n"
    "    void GpuSharedParameters.addConstantDefinition(Ogre::String const &name, Ogre::GpuConstantType constType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_removeConstantDefinition(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","removeConstantDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","removeConstantDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeConstantDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeConstantDefinition((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_removeAllConstantDefinitions(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","removeAllConstantDefinitions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  (arg1)->removeAllConstantDefinitions();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getVersion(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","getVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  result = (unsigned long)((Ogre::GpuSharedParameters const *)arg1)->getVersion();
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters__markDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","_markDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  (arg1)->_markDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getFrameLastUpdated(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","getFrameLastUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  result = ((Ogre::GpuSharedParameters const *)arg1)->getFrameLastUpdated();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getConstantDefinitionIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::GpuConstantDefinition,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::GpuConstantDefinition >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","getConstantDefinitionIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  result = ((Ogre::GpuSharedParameters const *)arg1)->getConstantDefinitionIterator();
  vresult = SWIG_NewPointerObj((new Ogre::GpuConstantDefinitionIterator(static_cast< const Ogre::GpuConstantDefinitionIterator& >(result))), 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_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getConstantDefinition(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::GpuConstantDefinition *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","getConstantDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","getConstantDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getConstantDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::GpuConstantDefinition *) &((Ogre::GpuSharedParameters const *)arg1)->getConstantDefinition((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuConstantDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getConstantDefinitions(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuNamedConstants *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","getConstantDefinitions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  result = (Ogre::GpuNamedConstants *) &((Ogre::GpuSharedParameters const *)arg1)->getConstantDefinitions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setNamedConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","setNamedConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector4 const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  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 &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = (Ogre::Matrix4 *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  float *arg3 = (float *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(float const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(double const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::ColourValue const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_setNamedConstant__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  int *arg3 = (int *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(int const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_setNamedConstant(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_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuSharedParameters_setNamedConstant__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(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_GpuSharedParameters_setNamedConstant__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuSharedParameters_setNamedConstant__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuSharedParameters_setNamedConstant__SWIG_8(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuSharedParameters_setNamedConstant__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 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_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuSharedParameters_setNamedConstant__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuSharedParameters_setNamedConstant__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuSharedParameters_setNamedConstant__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuSharedParameters_setNamedConstant__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuSharedParameters_setNamedConstant__SWIG_9(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuSharedParameters.setNamedConstant", 
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, Ogre::Real val)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, int val)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, Ogre::Vector4 const &vec)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, Ogre::Vector3 const &vec)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, Ogre::Matrix4 const &m)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, float const *val, size_t count)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, double const *val, size_t count)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, Ogre::ColourValue const &colour)\n"
    "    void GpuSharedParameters.setNamedConstant(Ogre::String const &name, int const *val, size_t count)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getFloatPointer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","getFloatPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getFloatPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float *)(arg1)->getFloatPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getFloatPointer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","getFloatPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getFloatPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float *)((Ogre::GpuSharedParameters const *)arg1)->getFloatPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_getFloatPointer(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_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuSharedParameters_getFloatPointer__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuSharedParameters_getFloatPointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuSharedParameters.getFloatPointer", 
    "    float const * GpuSharedParameters.getFloatPointer(size_t pos)\n"
    "    float const * GpuSharedParameters.getFloatPointer(size_t pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getIntPointer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters *","getIntPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getIntPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (int *)(arg1)->getIntPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters_getIntPointer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","getIntPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getIntPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (int *)((Ogre::GpuSharedParameters const *)arg1)->getIntPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuSharedParameters_getIntPointer(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_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuSharedParameters_getIntPointer__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuSharedParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuSharedParameters_getIntPointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuSharedParameters.getIntPointer", 
    "    int const * GpuSharedParameters.getIntPointer(size_t pos)\n"
    "    int const * GpuSharedParameters.getIntPointer(size_t pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters__setRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  Ogre::Any *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","_setRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","_setRenderSystemData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","_setRenderSystemData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  ((Ogre::GpuSharedParameters const *)arg1)->_setRenderSystemData((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParameters__getRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParameters *arg1 = (Ogre::GpuSharedParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__GpuSharedParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParameters const *","_getRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParameters * >(argp1);
  result = (Ogre::Any *) &((Ogre::GpuSharedParameters const *)arg1)->_getRenderSystemData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassGpuSharedParametersUsage;

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

SWIGINTERN VALUE
_wrap_new_GpuSharedParametersUsage(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuSharedParameters > > arg1 ;
  Ogre::GpuProgramParameters *arg2 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuSharedParametersUsage";
  Ogre::GpuSharedParametersUsage *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__SharedPtrT_Ogre__GpuSharedParameters_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersPtr","Ogre::GpuSharedParametersUsage", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuSharedParametersPtr","Ogre::GpuSharedParametersUsage", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::GpuSharedParametersPtr * >(argp1));
    }
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","Ogre::GpuSharedParametersUsage", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp2);
  result = (Ogre::GpuSharedParametersUsage *)new Ogre::GpuSharedParametersUsage(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage__copySharedParamsToTargetParams(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParametersUsage *arg1 = (Ogre::GpuSharedParametersUsage *) 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_Ogre__GpuSharedParametersUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersUsage *","_copySharedParamsToTargetParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParametersUsage * >(argp1);
  (arg1)->_copySharedParamsToTargetParams();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParametersUsage *arg1 = (Ogre::GpuSharedParametersUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuSharedParametersUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersUsage const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParametersUsage * >(argp1);
  result = (Ogre::String *) &((Ogre::GpuSharedParametersUsage const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage_getSharedParams(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParametersUsage *arg1 = (Ogre::GpuSharedParametersUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuSharedParameters > > 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_Ogre__GpuSharedParametersUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersUsage const *","getSharedParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParametersUsage * >(argp1);
  result = ((Ogre::GpuSharedParametersUsage const *)arg1)->getSharedParams();
  vresult = SWIG_NewPointerObj((new Ogre::GpuSharedParametersPtr(static_cast< const Ogre::GpuSharedParametersPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage_getTargetParams(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParametersUsage *arg1 = (Ogre::GpuSharedParametersUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramParameters *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_Ogre__GpuSharedParametersUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersUsage const *","getTargetParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParametersUsage * >(argp1);
  result = (Ogre::GpuProgramParameters *)((Ogre::GpuSharedParametersUsage const *)arg1)->getTargetParams();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage__setRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParametersUsage *arg1 = (Ogre::GpuSharedParametersUsage *) 0 ;
  Ogre::Any *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_Ogre__GpuSharedParametersUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersUsage const *","_setRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParametersUsage * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","_setRenderSystemData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","_setRenderSystemData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  ((Ogre::GpuSharedParametersUsage const *)arg1)->_setRenderSystemData((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuSharedParametersUsage__getRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuSharedParametersUsage *arg1 = (Ogre::GpuSharedParametersUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__GpuSharedParametersUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersUsage const *","_getRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuSharedParametersUsage * >(argp1);
  result = (Ogre::Any *) &((Ogre::GpuSharedParametersUsage const *)arg1)->_getRenderSystemData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuSharedParametersUsage(Ogre::GpuSharedParametersUsage *arg1) {
    delete arg1;
}

swig_class SwigClassGpuProgramParameters;

SWIGINTERN VALUE
_wrap_new_GpuProgramParameters__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuProgramParameters";
  Ogre::GpuProgramParameters *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuProgramParameters *)new Ogre::GpuProgramParameters();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuProgramParameters(Ogre::GpuProgramParameters *arg1) {
    delete arg1;
}

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

SWIGINTERN VALUE
_wrap_new_GpuProgramParameters__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuProgramParameters";
  Ogre::GpuProgramParameters *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__GpuProgramParameters,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const &","Ogre::GpuProgramParameters", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParameters const &","Ogre::GpuProgramParameters", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::GpuProgramParameters *)new Ogre::GpuProgramParameters((Ogre::GpuProgramParameters const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_GpuProgramParameters(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_GpuProgramParameters__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GpuProgramParameters__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuProgramParameters.new", 
    "    GpuProgramParameters.new()\n"
    "    GpuProgramParameters.new(Ogre::GpuProgramParameters const &oth)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__setNamedConstants(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::GpuNamedConstantsPtr *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_setNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuNamedConstants_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstantsPtr const &","_setNamedConstants", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuNamedConstantsPtr const &","_setNamedConstants", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuNamedConstantsPtr * >(argp2);
  (arg1)->_setNamedConstants((Ogre::GpuNamedConstantsPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__setLogicalIndexes(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::GpuLogicalBufferStructPtr *arg2 = 0 ;
  Ogre::GpuLogicalBufferStructPtr *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_setLogicalIndexes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuLogicalBufferStructPtr const &","_setLogicalIndexes", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuLogicalBufferStructPtr const &","_setLogicalIndexes", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuLogicalBufferStructPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuLogicalBufferStructPtr const &","_setLogicalIndexes", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuLogicalBufferStructPtr const &","_setLogicalIndexes", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::GpuLogicalBufferStructPtr * >(argp3);
  (arg1)->_setLogicalIndexes((Ogre::GpuLogicalBufferStructPtr const &)*arg2,(Ogre::GpuLogicalBufferStructPtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_hasNamedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","hasNamedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasNamedParameters();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_hasLogicalIndexedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","hasLogicalIndexedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasLogicalIndexedParameters();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Vector4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","setConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","setConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  (arg1)->setConstant(arg2,(Ogre::Vector4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 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","setConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setConstant(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 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 &","setConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->setConstant(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","setConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","setConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  (arg1)->setConstant(arg2,(Ogre::Matrix4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Matrix4 *arg3 = (Ogre::Matrix4 *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","setConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setConstant(arg2,(Ogre::Matrix4 const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  float *arg3 = (float *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float const *","setConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setConstant(arg2,(float const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","setConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setConstant(arg2,(double const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->setConstant(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstant__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  int *arg3 = (int *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const *","setConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setConstant(arg2,(int const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_setConstant(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_Ogre__GpuProgramParameters, 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__Vector4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters_setConstant__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_GpuProgramParameters_setConstant__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters_setConstant__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters_setConstant__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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) {
          return _wrap_GpuProgramParameters_setConstant__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setConstant__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setConstant__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setConstant__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setConstant__SWIG_8(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters.setConstant", 
    "    void GpuProgramParameters.setConstant(size_t index, Ogre::Vector4 const &vec)\n"
    "    void GpuProgramParameters.setConstant(size_t index, Ogre::Real val)\n"
    "    void GpuProgramParameters.setConstant(size_t index, Ogre::Vector3 const &vec)\n"
    "    void GpuProgramParameters.setConstant(size_t index, Ogre::Matrix4 const &m)\n"
    "    void GpuProgramParameters.setConstant(size_t index, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuProgramParameters.setConstant(size_t index, float const *val, size_t count)\n"
    "    void GpuProgramParameters.setConstant(size_t index, double const *val, size_t count)\n"
    "    void GpuProgramParameters.setConstant(size_t index, Ogre::ColourValue const &colour)\n"
    "    void GpuProgramParameters.setConstant(size_t index, int const *val, size_t count)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstants__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  float *arg3 = (float *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstants", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float const *","_writeRawConstants", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_writeRawConstants", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->_writeRawConstants(arg2,(float const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstants__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstants", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","_writeRawConstants", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_writeRawConstants", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->_writeRawConstants(arg2,(double const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstants__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  int *arg3 = (int *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstants", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const *","_writeRawConstants", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_writeRawConstants", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->_writeRawConstants(arg2,(int const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__writeRawConstants(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters__writeRawConstants__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters__writeRawConstants__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters__writeRawConstants__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters._writeRawConstants", 
    "    void GpuProgramParameters._writeRawConstants(size_t physicalIndex, float const *val, size_t count)\n"
    "    void GpuProgramParameters._writeRawConstants(size_t physicalIndex, double const *val, size_t count)\n"
    "    void GpuProgramParameters._writeRawConstants(size_t physicalIndex, int const *val, size_t count)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__readRawConstants__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  float *arg4 = (float *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_readRawConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_readRawConstants", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","_readRawConstants", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float *","_readRawConstants", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  (arg1)->_readRawConstants(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__readRawConstants__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  int *arg4 = (int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_readRawConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_readRawConstants", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","_readRawConstants", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int *","_readRawConstants", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  (arg1)->_readRawConstants(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__readRawConstants(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_GpuProgramParameters__readRawConstants__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_int, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_GpuProgramParameters__readRawConstants__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters._readRawConstants", 
    "    void GpuProgramParameters._readRawConstants(size_t physicalIndex, size_t count, float *dest)\n"
    "    void GpuProgramParameters._readRawConstants(size_t physicalIndex, size_t count, int *dest)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Vector4 *arg3 = 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","_writeRawConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","_writeRawConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->_writeRawConstant(arg2,(Ogre::Vector4 const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Vector4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","_writeRawConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","_writeRawConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  (arg1)->_writeRawConstant(arg2,(Ogre::Vector4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 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","_writeRawConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->_writeRawConstant(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","_writeRawConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->_writeRawConstant(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 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 &","_writeRawConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","_writeRawConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->_writeRawConstant(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Matrix4 *arg3 = 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","_writeRawConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_writeRawConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->_writeRawConstant(arg2,(Ogre::Matrix4 const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Matrix4 *arg3 = (Ogre::Matrix4 *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","_writeRawConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->_writeRawConstant(arg2,(Ogre::Matrix4 const *)arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_writeRawConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_writeRawConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->_writeRawConstant(arg2,(Ogre::ColourValue const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__writeRawConstant__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_writeRawConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_writeRawConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_writeRawConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_writeRawConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->_writeRawConstant(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__writeRawConstant(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_Ogre__GpuProgramParameters, 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__Vector4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters__writeRawConstant__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_GpuProgramParameters__writeRawConstant__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters__writeRawConstant__SWIG_8(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramParameters__writeRawConstant__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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) {
          return _wrap_GpuProgramParameters__writeRawConstant__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters__writeRawConstant__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters__writeRawConstant__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters__writeRawConstant__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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__Vector4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters__writeRawConstant__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "GpuProgramParameters._writeRawConstant", 
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::Vector4 const &vec, size_t count)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::Vector4 const &vec)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::Real val)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, int val)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::Vector3 const &vec)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::Matrix4 const &m, size_t elementCount)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::ColourValue const &colour, size_t count)\n"
    "    void GpuProgramParameters._writeRawConstant(size_t physicalIndex, Ogre::ColourValue const &colour)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getConstantDefinitionIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::GpuConstantDefinition,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::GpuConstantDefinition >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getConstantDefinitionIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = ((Ogre::GpuProgramParameters const *)arg1)->getConstantDefinitionIterator();
  vresult = SWIG_NewPointerObj((new Ogre::GpuConstantDefinitionIterator(static_cast< const Ogre::GpuConstantDefinitionIterator& >(result))), 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_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getConstantDefinition(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::GpuConstantDefinition *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getConstantDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","getConstantDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getConstantDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::GpuConstantDefinition *) &((Ogre::GpuProgramParameters const *)arg1)->getConstantDefinition((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuConstantDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getConstantDefinitions(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuNamedConstants *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getConstantDefinitions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::GpuNamedConstants *) &((Ogre::GpuProgramParameters const *)arg1)->getConstantDefinitions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getFloatLogicalBufferStruct(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuLogicalBufferStructPtr *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getFloatLogicalBufferStruct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::GpuLogicalBufferStructPtr *) &((Ogre::GpuProgramParameters const *)arg1)->getFloatLogicalBufferStruct();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getFloatLogicalIndexForPhysicalIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","getFloatLogicalIndexForPhysicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getFloatLogicalIndexForPhysicalIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (arg1)->getFloatLogicalIndexForPhysicalIndex(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getIntLogicalIndexForPhysicalIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","getIntLogicalIndexForPhysicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getIntLogicalIndexForPhysicalIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (arg1)->getIntLogicalIndexForPhysicalIndex(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getIntLogicalBufferStruct(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuLogicalBufferStructPtr *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getIntLogicalBufferStruct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::GpuLogicalBufferStructPtr *) &((Ogre::GpuProgramParameters const *)arg1)->getIntLogicalBufferStruct();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuLogicalBufferStruct_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getFloatConstantList(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::FloatConstantList *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getFloatConstantList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::FloatConstantList *) &((Ogre::GpuProgramParameters const *)arg1)->getFloatConstantList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_float_Ogre__STLAllocatorT_float_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getFloatPointer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","getFloatPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getFloatPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float *)(arg1)->getFloatPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getFloatPointer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getFloatPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getFloatPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float *)((Ogre::GpuProgramParameters const *)arg1)->getFloatPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_getFloatPointer(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_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuProgramParameters_getFloatPointer__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuProgramParameters_getFloatPointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuProgramParameters.getFloatPointer", 
    "    float const * GpuProgramParameters.getFloatPointer(size_t pos)\n"
    "    float const * GpuProgramParameters.getFloatPointer(size_t pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getIntConstantList(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IntConstantList *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getIntConstantList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::IntConstantList *) &((Ogre::GpuProgramParameters const *)arg1)->getIntConstantList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_int_Ogre__STLAllocatorT_int_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getIntPointer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","getIntPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getIntPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (int *)(arg1)->getIntPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getIntPointer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getIntPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getIntPointer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (int *)((Ogre::GpuProgramParameters const *)arg1)->getIntPointer(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_getIntPointer(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_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuProgramParameters_getIntPointer__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_GpuProgramParameters_getIntPointer__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuProgramParameters.getIntPointer", 
    "    int const * GpuProgramParameters.getIntPointer(size_t pos)\n"
    "    int const * GpuProgramParameters.getIntPointer(size_t pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getAutoConstantList(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramParameters::AutoConstantList *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getAutoConstantList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::GpuProgramParameters::AutoConstantList *) &((Ogre::GpuProgramParameters const *)arg1)->getAutoConstantList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setAutoConstant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setAutoConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setAutoConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setAutoConstant(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setAutoConstant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setAutoConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  (arg1)->setAutoConstant(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setAutoConstantReal(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setAutoConstantReal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setAutoConstantReal", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setAutoConstantReal", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setAutoConstantReal", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setAutoConstantReal(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setAutoConstant__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  Ogre::uint16 arg4 ;
  Ogre::uint16 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setAutoConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","setAutoConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","setAutoConstant", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  (arg1)->setAutoConstant(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_setAutoConstant(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_Ogre__GpuProgramParameters, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramParameters_setAutoConstant__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setAutoConstant__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_GpuProgramParameters_setAutoConstant__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "GpuProgramParameters.setAutoConstant", 
    "    void GpuProgramParameters.setAutoConstant(size_t index, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo)\n"
    "    void GpuProgramParameters.setAutoConstant(size_t index, Ogre::GpuProgramParameters::AutoConstantType acType)\n"
    "    void GpuProgramParameters.setAutoConstant(size_t index, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::uint16 extraInfo1, Ogre::uint16 extraInfo2)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__setRawAutoConstant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  size_t arg4 ;
  Ogre::uint16 arg5 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_setRawAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","_setRawAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","_setRawAutoConstant", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstant", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  (arg1)->_setRawAutoConstant(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__setRawAutoConstant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  size_t arg4 ;
  Ogre::uint16 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_setRawAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","_setRawAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","_setRawAutoConstant", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  (arg1)->_setRawAutoConstant(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__setRawAutoConstant(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_GpuProgramParameters__setRawAutoConstant__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_GpuProgramParameters__setRawAutoConstant__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "GpuProgramParameters._setRawAutoConstant", 
    "    void GpuProgramParameters._setRawAutoConstant(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo, Ogre::uint16 variability, size_t elementSize)\n"
    "    void GpuProgramParameters._setRawAutoConstant(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo, Ogre::uint16 variability)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__setRawAutoConstantReal__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  Ogre::Real arg4 ;
  Ogre::uint16 arg5 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_setRawAutoConstantReal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstantReal", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","_setRawAutoConstantReal", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setRawAutoConstantReal", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","_setRawAutoConstantReal", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstantReal", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  (arg1)->_setRawAutoConstantReal(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__setRawAutoConstantReal__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  Ogre::Real arg4 ;
  Ogre::uint16 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_setRawAutoConstantReal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setRawAutoConstantReal", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","_setRawAutoConstantReal", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setRawAutoConstantReal", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","_setRawAutoConstantReal", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  (arg1)->_setRawAutoConstantReal(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__setRawAutoConstantReal(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int(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_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_GpuProgramParameters__setRawAutoConstantReal__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_int(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_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_GpuProgramParameters__setRawAutoConstantReal__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "GpuProgramParameters._setRawAutoConstantReal", 
    "    void GpuProgramParameters._setRawAutoConstantReal(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::Real rData, Ogre::uint16 variability, size_t elementSize)\n"
    "    void GpuProgramParameters._setRawAutoConstantReal(size_t physicalIndex, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::Real rData, Ogre::uint16 variability)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_clearAutoConstant(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","clearAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","clearAutoConstant", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->clearAutoConstant(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setConstantFromTime(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setConstantFromTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setConstantFromTime", 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","setConstantFromTime", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setConstantFromTime(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_clearAutoConstants(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","clearAutoConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  (arg1)->clearAutoConstants();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getAutoConstantIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< AutoConstantEntry,Ogre::STLAllocator< AutoConstantEntry,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getAutoConstantIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = ((Ogre::GpuProgramParameters const *)arg1)->getAutoConstantIterator();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParameters::AutoConstantIterator(static_cast< const Ogre::GpuProgramParameters::AutoConstantIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getAutoConstantCount(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getAutoConstantCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = ((Ogre::GpuProgramParameters const *)arg1)->getAutoConstantCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getAutoConstantEntry(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AutoConstantEntry *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","getAutoConstantEntry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getAutoConstantEntry", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (AutoConstantEntry *)(arg1)->getAutoConstantEntry(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_hasAutoConstants(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","hasAutoConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasAutoConstants();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_findFloatAutoConstantEntry(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AutoConstantEntry *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","findFloatAutoConstantEntry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","findFloatAutoConstantEntry", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (AutoConstantEntry *)(arg1)->findFloatAutoConstantEntry(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_findIntAutoConstantEntry(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AutoConstantEntry *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","findIntAutoConstantEntry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","findIntAutoConstantEntry", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (AutoConstantEntry *)(arg1)->findIntAutoConstantEntry(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_findAutoConstantEntry(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  AutoConstantEntry *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","findAutoConstantEntry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","findAutoConstantEntry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findAutoConstantEntry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (AutoConstantEntry *)(arg1)->findAutoConstantEntry((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__findRawAutoConstantEntryFloat(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AutoConstantEntry *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_findRawAutoConstantEntryFloat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_findRawAutoConstantEntryFloat", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (AutoConstantEntry *)(arg1)->_findRawAutoConstantEntryFloat(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__findRawAutoConstantEntryInt(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  AutoConstantEntry *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_findRawAutoConstantEntryInt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_findRawAutoConstantEntryInt", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (AutoConstantEntry *)(arg1)->_findRawAutoConstantEntryInt(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_AutoConstantEntry, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__updateAutoParams(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::AutoParamDataSource *arg2 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_updateAutoParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","_updateAutoParams", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","_updateAutoParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  (arg1)->_updateAutoParams((Ogre::AutoParamDataSource const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setIgnoreMissingParams(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setIgnoreMissingParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setIgnoreMissingParams", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setIgnoreMissingParams(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setNamedConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","setNamedConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector4 const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  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 &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = (Ogre::Matrix4 *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::Matrix4 const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  float *arg3 = (float *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(float const *)arg3,arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  float *arg3 = (float *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(float const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(double const *)arg3,arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  double *arg3 = (double *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_double, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "double const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< double * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(double const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setNamedConstant", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setNamedConstant", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(Ogre::ColourValue const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  int *arg3 = (int *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(int const *)arg3,arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstant__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  int *arg3 = (int *) 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int const *","setNamedConstant", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedConstant((Ogre::String const &)*arg2,(int const *)arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_setNamedConstant(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_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters_setNamedConstant__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(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_GpuProgramParameters_setNamedConstant__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters_setNamedConstant__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_GpuProgramParameters_setNamedConstant__SWIG_10(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramParameters_setNamedConstant__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramParameters_setNamedConstant__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setNamedConstant__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setNamedConstant__SWIG_9(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setNamedConstant__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setNamedConstant__SWIG_12(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_double, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_GpuProgramParameters_setNamedConstant__SWIG_8(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_int, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_GpuProgramParameters_setNamedConstant__SWIG_11(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_GpuProgramParameters_setNamedConstant__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "GpuProgramParameters.setNamedConstant", 
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, Ogre::Real val)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, int val)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, Ogre::Vector4 const &vec)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, Ogre::Vector3 const &vec)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, Ogre::Matrix4 const &m)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, Ogre::Matrix4 const *m, size_t numEntries)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, float const *val, size_t count, size_t multiple)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, float const *val, size_t count)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, double const *val, size_t count, size_t multiple)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, double const *val, size_t count)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, Ogre::ColourValue const &colour)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, int const *val, size_t count, size_t multiple)\n"
    "    void GpuProgramParameters.setNamedConstant(Ogre::String const &name, int const *val, size_t count)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedAutoConstant__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedAutoConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedAutoConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setNamedAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setNamedAutoConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setNamedAutoConstant((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedAutoConstant__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedAutoConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedAutoConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setNamedAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  (arg1)->setNamedAutoConstant((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedAutoConstantReal(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedAutoConstantReal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedAutoConstantReal", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedAutoConstantReal", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setNamedAutoConstantReal", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setNamedAutoConstantReal", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setNamedAutoConstantReal((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedAutoConstant__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuProgramParameters::AutoConstantType arg3 ;
  Ogre::uint16 arg4 ;
  Ogre::uint16 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedAutoConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedAutoConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantType","setNamedAutoConstant", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::GpuProgramParameters::AutoConstantType >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","setNamedAutoConstant", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","setNamedAutoConstant", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  (arg1)->setNamedAutoConstant((Ogre::String const &)*arg2,arg3,arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_setNamedAutoConstant(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_Ogre__GpuProgramParameters, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramParameters_setNamedAutoConstant__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_GpuProgramParameters_setNamedAutoConstant__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_GpuProgramParameters_setNamedAutoConstant__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "GpuProgramParameters.setNamedAutoConstant", 
    "    void GpuProgramParameters.setNamedAutoConstant(Ogre::String const &name, Ogre::GpuProgramParameters::AutoConstantType acType, size_t extraInfo)\n"
    "    void GpuProgramParameters.setNamedAutoConstant(Ogre::String const &name, Ogre::GpuProgramParameters::AutoConstantType acType)\n"
    "    void GpuProgramParameters.setNamedAutoConstant(Ogre::String const &name, Ogre::GpuProgramParameters::AutoConstantType acType, Ogre::uint16 extraInfo1, Ogre::uint16 extraInfo2)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setNamedConstantFromTime(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setNamedConstantFromTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","setNamedConstantFromTime", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setNamedConstantFromTime", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setNamedConstantFromTime", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setNamedConstantFromTime((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_clearNamedAutoConstant(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","clearNamedAutoConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","clearNamedAutoConstant", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clearNamedAutoConstant", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->clearNamedAutoConstant((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__findNamedConstantDefinition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::GpuConstantDefinition *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","_findNamedConstantDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","_findNamedConstantDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_findNamedConstantDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_findNamedConstantDefinition", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::GpuConstantDefinition *)((Ogre::GpuProgramParameters const *)arg1)->_findNamedConstantDefinition((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuConstantDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__findNamedConstantDefinition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::GpuConstantDefinition *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","_findNamedConstantDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","_findNamedConstantDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_findNamedConstantDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::GpuConstantDefinition *)((Ogre::GpuProgramParameters const *)arg1)->_findNamedConstantDefinition((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuConstantDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters__findNamedConstantDefinition(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_Ogre__GpuProgramParameters, 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_GpuProgramParameters__findNamedConstantDefinition__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramParameters__findNamedConstantDefinition__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "GpuProgramParameters._findNamedConstantDefinition", 
    "    Ogre::GpuConstantDefinition const * GpuProgramParameters._findNamedConstantDefinition(Ogre::String const &name, bool throwExceptionIfMissing)\n"
    "    Ogre::GpuConstantDefinition const * GpuProgramParameters._findNamedConstantDefinition(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__getFloatConstantPhysicalIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::uint16 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  size_t 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_getFloatConstantPhysicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_getFloatConstantPhysicalIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","_getFloatConstantPhysicalIndex", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","_getFloatConstantPhysicalIndex", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  result = (arg1)->_getFloatConstantPhysicalIndex(arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__getIntConstantPhysicalIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::uint16 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  size_t 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_getIntConstantPhysicalIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_getIntConstantPhysicalIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","_getIntConstantPhysicalIndex", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","_getIntConstantPhysicalIndex", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  result = (arg1)->_getIntConstantPhysicalIndex(arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_setTransposeMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","setTransposeMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTransposeMatrices", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTransposeMatrices(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getTransposeMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getTransposeMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (bool)((Ogre::GpuProgramParameters const *)arg1)->getTransposeMatrices();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_copyConstantsFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::GpuProgramParameters *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","copyConstantsFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__GpuProgramParameters,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const &","copyConstantsFrom", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParameters const &","copyConstantsFrom", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp2);
  (arg1)->copyConstantsFrom((Ogre::GpuProgramParameters const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_copyMatchingNamedConstantsFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::GpuProgramParameters *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","copyMatchingNamedConstantsFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__GpuProgramParameters,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const &","copyMatchingNamedConstantsFrom", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParameters const &","copyMatchingNamedConstantsFrom", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp2);
  (arg1)->copyMatchingNamedConstantsFrom((Ogre::GpuProgramParameters const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getAutoConstantDefinition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::GpuProgramParameters::AutoConstantDefinition *result = 0 ;
  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( "", "Ogre::String const &","Ogre::GpuProgramParameters::getAutoConstantDefinition", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::GpuProgramParameters::getAutoConstantDefinition", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::GpuProgramParameters::AutoConstantDefinition *)Ogre::GpuProgramParameters::getAutoConstantDefinition((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getAutoConstantDefinition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  Ogre::GpuProgramParameters::AutoConstantDefinition *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::GpuProgramParameters::getAutoConstantDefinition", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  result = (Ogre::GpuProgramParameters::AutoConstantDefinition *)Ogre::GpuProgramParameters::getAutoConstantDefinition(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantDefinition, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_getAutoConstantDefinition(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_GpuProgramParameters_getAutoConstantDefinition__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_GpuProgramParameters_getAutoConstantDefinition__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuProgramParameters.getAutoConstantDefinition", 
    "    Ogre::GpuProgramParameters::AutoConstantDefinition const * GpuProgramParameters.getAutoConstantDefinition(Ogre::String const &name)\n"
    "    Ogre::GpuProgramParameters::AutoConstantDefinition const * GpuProgramParameters.getAutoConstantDefinition(size_t const idx)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getNumAutoConstantDefinitions(int argc, VALUE *argv, VALUE self) {
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = Ogre::GpuProgramParameters::getNumAutoConstantDefinitions();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_incPassIterationNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","incPassIterationNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  (arg1)->incPassIterationNumber();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_hasPassIterationNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","hasPassIterationNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (bool)((Ogre::GpuProgramParameters const *)arg1)->hasPassIterationNumber();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getPassIterationNumberIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getPassIterationNumberIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = ((Ogre::GpuProgramParameters const *)arg1)->getPassIterationNumberIndex();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_addSharedParameters__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuSharedParameters > > arg2 ;
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","addSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuSharedParametersPtr","addSharedParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuSharedParametersPtr","addSharedParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuSharedParametersPtr * >(argp2));
    }
  }
  (arg1)->addSharedParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_addSharedParameters__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","addSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","addSharedParameters", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addSharedParameters", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addSharedParameters((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramParameters_addSharedParameters(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_Ogre__GpuProgramParameters, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_GpuProgramParameters_addSharedParameters__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramParameters, 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_GpuProgramParameters_addSharedParameters__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "GpuProgramParameters.addSharedParameters", 
    "    void GpuProgramParameters.addSharedParameters(Ogre::GpuSharedParametersPtr sharedParams)\n"
    "    void GpuProgramParameters.addSharedParameters(Ogre::String const &sharedParamsName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_isUsingSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","isUsingSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","isUsingSharedParameters", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isUsingSharedParameters", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::GpuProgramParameters const *)arg1)->isUsingSharedParameters((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_removeSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","removeSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(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( "", "Ogre::String const &","removeSharedParameters", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeSharedParameters", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeSharedParameters((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_removeAllSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","removeAllSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  (arg1)->removeAllSharedParameters();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters_getSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramParameters::GpuSharedParamUsageList *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","getSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::GpuProgramParameters::GpuSharedParamUsageList *) &((Ogre::GpuProgramParameters const *)arg1)->getSharedParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__setRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  Ogre::Any *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","_setRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","_setRenderSystemData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","_setRenderSystemData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  ((Ogre::GpuProgramParameters const *)arg1)->_setRenderSystemData((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__getRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters const *","_getRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  result = (Ogre::Any *) &((Ogre::GpuProgramParameters const *)arg1)->_getRenderSystemData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramParameters__copySharedParams(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramParameters *arg1 = (Ogre::GpuProgramParameters *) 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_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_copySharedParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp1);
  (arg1)->_copySharedParams();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassGpuProgram;

SWIGINTERN void
free_Ogre_GpuProgram(Ogre::GpuProgram *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_GpuProgram_setSourceFile(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  Ogre::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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setSourceFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(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( "", "Ogre::String const &","setSourceFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSourceFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSourceFile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setSource(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  Ogre::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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(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( "", "Ogre::String const &","setSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSource((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getSyntaxCode(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getSyntaxCode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getSyntaxCode();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setSyntaxCode(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  Ogre::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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setSyntaxCode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(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( "", "Ogre::String const &","setSyntaxCode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSyntaxCode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSyntaxCode((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getSourceFile(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getSourceFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getSourceFile();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getSource(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getSource();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setType(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  Ogre::GpuProgramType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","setType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  (arg1)->setType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramType 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::GpuProgramType)((Ogre::GpuProgram const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram__getBindingDelegate(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgram *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","_getBindingDelegate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::GpuProgram *)(arg1)->_getBindingDelegate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgram, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_isSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","isSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->isSupported();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_createParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","createParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (arg1)->createParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setSkeletalAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setSkeletalAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkeletalAnimationIncluded", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSkeletalAnimationIncluded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_isSkeletalAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","isSkeletalAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->isSkeletalAnimationIncluded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setMorphAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setMorphAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setMorphAnimationIncluded", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setMorphAnimationIncluded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setPoseAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setPoseAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setPoseAnimationIncluded", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setPoseAnimationIncluded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_isMorphAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","isMorphAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->isMorphAnimationIncluded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_isPoseAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","isPoseAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->isPoseAnimationIncluded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getNumberOfPosesIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getNumberOfPosesIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::ushort)((Ogre::GpuProgram const *)arg1)->getNumberOfPosesIncluded();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setVertexTextureFetchRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setVertexTextureFetchRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVertexTextureFetchRequired", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVertexTextureFetchRequired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_isVertexTextureFetchRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","isVertexTextureFetchRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->isVertexTextureFetchRequired();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setAdjacencyInfoRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setAdjacencyInfoRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAdjacencyInfoRequired", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAdjacencyInfoRequired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_isAdjacencyInfoRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","isAdjacencyInfoRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->isAdjacencyInfoRequired();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getDefaultParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","getDefaultParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (arg1)->getDefaultParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_hasDefaultParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","hasDefaultParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->hasDefaultParameters();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getPassSurfaceAndLightStates(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getPassSurfaceAndLightStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->getPassSurfaceAndLightStates();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getPassFogStates(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getPassFogStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->getPassFogStates();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getPassTransformStates(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getPassTransformStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->getPassTransformStates();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getLanguage(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getLanguage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getLanguage();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_hasCompileError(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","hasCompileError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (bool)((Ogre::GpuProgram const *)arg1)->hasCompileError();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_resetCompileError(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","resetCompileError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  (arg1)->resetCompileError();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setManualNamedConstants(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  Ogre::GpuNamedConstants *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setManualNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__GpuNamedConstants,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuNamedConstants const &","setManualNamedConstants", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuNamedConstants const &","setManualNamedConstants", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuNamedConstants * >(argp2);
  (arg1)->setManualNamedConstants((Ogre::GpuNamedConstants const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getNamedConstants(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuNamedConstants *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::GpuNamedConstants *) &((Ogre::GpuProgram const *)arg1)->getNamedConstants();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_setManualNamedConstantsFile(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  Ogre::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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","setManualNamedConstantsFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(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( "", "Ogre::String const &","setManualNamedConstantsFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setManualNamedConstantsFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setManualNamedConstantsFile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getManualNamedConstantsFile(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getManualNamedConstantsFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::String *) &((Ogre::GpuProgram const *)arg1)->getManualNamedConstantsFile();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgram_getConstantDefinitions(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuNamedConstants *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_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram const *","getConstantDefinitions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::GpuNamedConstants *) &((Ogre::GpuProgram const *)arg1)->getConstantDefinitions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassGpuProgramPtr;

SWIGINTERN VALUE
_wrap_new_GpuProgramPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuProgramPtr";
  Ogre::GpuProgramPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_GpuProgramPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgram *arg1 = (Ogre::GpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuProgramPtr";
  Ogre::GpuProgramPtr *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__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","Ogre::GpuProgramPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgram * >(argp1);
  result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_GpuProgramPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuProgramPtr";
  Ogre::GpuProgramPtr *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__GpuProgramPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramPtr const &","Ogre::GpuProgramPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramPtr const &","Ogre::GpuProgramPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramPtr * >(argp1);
  result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr((Ogre::GpuProgramPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_GpuProgramPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuProgramPtr";
  Ogre::GpuProgramPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::GpuProgramPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::GpuProgramPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::GpuProgramPtr *)new Ogre::GpuProgramPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_GpuProgramPtr(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_GpuProgramPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgram, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GpuProgramPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GpuProgramPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_GpuProgramPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "GpuProgramPtr.new", 
    "    GpuProgramPtr.new()\n"
    "    GpuProgramPtr.new(Ogre::GpuProgram *rep)\n"
    "    GpuProgramPtr.new(Ogre::GpuProgramPtr const &r)\n"
    "    GpuProgramPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuProgramPtr(Ogre::GpuProgramPtr *arg1) {
    delete arg1;
}

swig_class SwigClassUserObjectBindings;

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

SWIGINTERN VALUE
_wrap_new_UserObjectBindings(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::UserObjectBindings";
  Ogre::UserObjectBindings *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::UserObjectBindings *)new Ogre::UserObjectBindings();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_UserObjectBindings(Ogre::UserObjectBindings *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_UserObjectBindings_setUserAny__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UserObjectBindings *arg1 = (Ogre::UserObjectBindings *) 0 ;
  Ogre::Any *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_Ogre__UserObjectBindings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UserObjectBindings *","setUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UserObjectBindings * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","setUserAny", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","setUserAny", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  (arg1)->setUserAny((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UserObjectBindings_getUserAny__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UserObjectBindings *arg1 = (Ogre::UserObjectBindings *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__UserObjectBindings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UserObjectBindings const *","getUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UserObjectBindings * >(argp1);
  result = (Ogre::Any *) &((Ogre::UserObjectBindings const *)arg1)->getUserAny();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UserObjectBindings_setUserAny__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UserObjectBindings *arg1 = (Ogre::UserObjectBindings *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Any *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__UserObjectBindings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UserObjectBindings *","setUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UserObjectBindings * >(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( "", "Ogre::String const &","setUserAny", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setUserAny", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Any const &","setUserAny", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","setUserAny", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Any * >(argp3);
  (arg1)->setUserAny((Ogre::String const &)*arg2,(Ogre::Any const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_UserObjectBindings_setUserAny(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_Ogre__UserObjectBindings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Any, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UserObjectBindings_setUserAny__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UserObjectBindings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Any, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UserObjectBindings_setUserAny__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "UserObjectBindings.setUserAny", 
    "    void UserObjectBindings.setUserAny(Ogre::Any const &anything)\n"
    "    void UserObjectBindings.setUserAny(Ogre::String const &key, Ogre::Any const &anything)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UserObjectBindings_getUserAny__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UserObjectBindings *arg1 = (Ogre::UserObjectBindings *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Any *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_Ogre__UserObjectBindings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UserObjectBindings const *","getUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UserObjectBindings * >(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( "", "Ogre::String const &","getUserAny", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getUserAny", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Any *) &((Ogre::UserObjectBindings const *)arg1)->getUserAny((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_UserObjectBindings_getUserAny(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_Ogre__UserObjectBindings, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UserObjectBindings_getUserAny__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UserObjectBindings, 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_UserObjectBindings_getUserAny__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UserObjectBindings.getUserAny", 
    "    Ogre::Any const & UserObjectBindings.getUserAny()\n"
    "    Ogre::Any const & UserObjectBindings.getUserAny(Ogre::String const &key)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UserObjectBindings_eraseUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::UserObjectBindings *arg1 = (Ogre::UserObjectBindings *) 0 ;
  Ogre::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_Ogre__UserObjectBindings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UserObjectBindings *","eraseUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UserObjectBindings * >(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( "", "Ogre::String const &","eraseUserAny", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","eraseUserAny", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->eraseUserAny((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}



/*
  Document-method: Ogre::UserObjectBindings.clear

  call-seq:
    clear

Clear UserObjectBindings contents.
*/
SWIGINTERN VALUE
_wrap_UserObjectBindings_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::UserObjectBindings *arg1 = (Ogre::UserObjectBindings *) 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_Ogre__UserObjectBindings, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UserObjectBindings const *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UserObjectBindings * >(argp1);
  ((Ogre::UserObjectBindings const *)arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UserObjectBindings_getEmptyUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::Any *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Any *) &Ogre::UserObjectBindings::getEmptyUserAny();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRenderable;

SWIGINTERN void
free_Ogre_Renderable(Ogre::Renderable *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Renderable_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::Renderable const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (Ogre::Technique *)((Ogre::Renderable const *)arg1)->getTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::RenderOperation *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_preRender(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderSystem *arg3 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","preRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","preRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","preRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderSystem * >(argp3);
  result = (bool)(arg1)->preRender(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_postRender(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderSystem *arg3 = (Ogre::RenderSystem *) 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","postRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","postRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","postRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderSystem * >(argp3);
  (arg1)->postRender(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::Renderable const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getNumWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getNumWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (unsigned short)((Ogre::Renderable const *)arg1)->getNumWorldTransforms();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_setUseIdentityProjection(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","setUseIdentityProjection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseIdentityProjection", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseIdentityProjection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getUseIdentityProjection(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getUseIdentityProjection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (bool)((Ogre::Renderable const *)arg1)->getUseIdentityProjection();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_setUseIdentityView(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","setUseIdentityView", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseIdentityView", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseIdentityView(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getUseIdentityView(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getUseIdentityView", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (bool)((Ogre::Renderable const *)arg1)->getUseIdentityView();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::Renderable const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (Ogre::LightList *) &((Ogre::Renderable const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getCastsShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getCastsShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (bool)((Ogre::Renderable const *)arg1)->getCastsShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_setCustomParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  size_t arg2 ;
  Ogre::Vector4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","setCustomParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setCustomParameter", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","setCustomParameter", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","setCustomParameter", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  (arg1)->setCustomParameter(arg2,(Ogre::Vector4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_removeCustomParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","removeCustomParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removeCustomParameter", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removeCustomParameter(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_hasCustomParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","hasCustomParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","hasCustomParameter", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (bool)((Ogre::Renderable const *)arg1)->hasCustomParameter(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getCustomParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getCustomParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getCustomParameter", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Vector4 *) &((Ogre::Renderable const *)arg1)->getCustomParameter(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable__updateCustomGpuParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::GpuProgramParameters::AutoConstantEntry *arg2 = 0 ;
  Ogre::GpuProgramParameters *arg3 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","_updateCustomGpuParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantEntry const &","_updateCustomGpuParameter", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParameters::AutoConstantEntry const &","_updateCustomGpuParameter", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramParameters::AutoConstantEntry * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_updateCustomGpuParameter", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp3);
  ((Ogre::Renderable const *)arg1)->_updateCustomGpuParameter((Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_setPolygonModeOverrideable(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","setPolygonModeOverrideable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPolygonModeOverrideable", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPolygonModeOverrideable(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getPolygonModeOverrideable(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getPolygonModeOverrideable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (bool)((Ogre::Renderable const *)arg1)->getPolygonModeOverrideable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_setUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::Any *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","setUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","setUserAny", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","setUserAny", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  (arg1)->setUserAny((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (Ogre::Any *) &((Ogre::Renderable const *)arg1)->getUserAny();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getUserObjectBindings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getUserObjectBindings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (Ogre::UserObjectBindings *) &((Ogre::Renderable const *)arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Renderable_getUserObjectBindings(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_Ogre__Renderable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Renderable_getUserObjectBindings__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Renderable_getUserObjectBindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Renderable.getUserObjectBindings", 
    "    Ogre::UserObjectBindings const & Renderable.getUserObjectBindings()\n"
    "    Ogre::UserObjectBindings const & Renderable.getUserObjectBindings()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_getRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Renderable::RenderSystemData *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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","getRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  result = (Ogre::Renderable::RenderSystemData *)((Ogre::Renderable const *)arg1)->getRenderSystemData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable__RenderSystemData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Renderable_setRenderSystemData(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::Renderable::RenderSystemData *arg2 = (Ogre::Renderable::RenderSystemData *) 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_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable const *","setRenderSystemData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__RenderSystemData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::RenderSystemData *","setRenderSystemData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::RenderSystemData * >(argp2);
  ((Ogre::Renderable const *)arg1)->setRenderSystemData(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassShadowRenderable;

SWIGINTERN void
free_Ogre_ShadowRenderable(Ogre::ShadowRenderable *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ShadowRenderable_setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  Ogre::MaterialPtr *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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable *","setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::ShadowRenderable const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  Ogre::RenderOperation *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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_getRenderOperationForUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderOperation *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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable *","getRenderOperationForUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  result = (Ogre::RenderOperation *)(arg1)->getRenderOperationForUpdate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderOperation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::ShadowRenderable const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::ShadowRenderable const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  result = (Ogre::LightList *) &((Ogre::ShadowRenderable const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_isLightCapSeparate(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable const *","isLightCapSeparate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  result = (bool)((Ogre::ShadowRenderable const *)arg1)->isLightCapSeparate();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_getLightCapRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ShadowRenderable *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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable *","getLightCapRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  result = (Ogre::ShadowRenderable *)(arg1)->getLightCapRenderable();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ShadowRenderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  result = (bool)((Ogre::ShadowRenderable const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowRenderable_rebindIndexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowRenderable *arg1 = (Ogre::ShadowRenderable *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *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_Ogre__ShadowRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowRenderable *","rebindIndexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr const &","rebindIndexBuffer", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareIndexBufferSharedPtr const &","rebindIndexBuffer", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp2);
  (arg1)->rebindIndexBuffer((Ogre::HardwareIndexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassShadowCaster;

SWIGINTERN void
free_Ogre_ShadowCaster(Ogre::ShadowCaster *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ShadowCaster_getCastShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster const *","getCastShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  result = (bool)((Ogre::ShadowCaster const *)arg1)->getCastShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  result = (Ogre::EdgeData *)(arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_hasEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster *","hasEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  result = (bool)(arg1)->hasEdgeList();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getWorldBoundingBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster const *","getWorldBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getWorldBoundingBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getWorldBoundingBox(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getWorldBoundingBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster const *","getWorldBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getWorldBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ShadowCaster_getWorldBoundingBox(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_Ogre__ShadowCaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ShadowCaster_getWorldBoundingBox__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ShadowCaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ShadowCaster_getWorldBoundingBox__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ShadowCaster.getWorldBoundingBox", 
    "    Ogre::AxisAlignedBox const & ShadowCaster.getWorldBoundingBox(bool derive)\n"
    "    Ogre::AxisAlignedBox const & ShadowCaster.getWorldBoundingBox()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getLightCapBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster const *","getLightCapBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getLightCapBounds();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getDarkCapBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  Ogre::Light *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster const *","getDarkCapBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Light,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light const &","getDarkCapBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Light const &","getDarkCapBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","getDarkCapBounds", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::AxisAlignedBox *) &((Ogre::ShadowCaster const *)arg1)->getDarkCapBounds((Ogre::Light const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getShadowVolumeRenderableIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  unsigned long arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "unsigned long","getShadowVolumeRenderableIterator", 7, argv[5] ));
  } 
  arg7 = static_cast< unsigned long >(val7);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getShadowVolumeRenderableIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ShadowCaster_getShadowVolumeRenderableIterator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ShadowCaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ShadowCaster_getShadowVolumeRenderableIterator__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ShadowCaster, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ShadowCaster_getShadowVolumeRenderableIterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "ShadowCaster.getShadowVolumeRenderableIterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ShadowCaster.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ShadowCaster.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_extrudeVertices(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareVertexBufferSharedPtr *arg1 = 0 ;
  size_t arg2 ;
  Ogre::Vector4 *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","Ogre::ShadowCaster::extrudeVertices", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","Ogre::ShadowCaster::extrudeVertices", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::ShadowCaster::extrudeVertices", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","Ogre::ShadowCaster::extrudeVertices", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","Ogre::ShadowCaster::extrudeVertices", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::ShadowCaster::extrudeVertices", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  Ogre::ShadowCaster::extrudeVertices((Ogre::HardwareVertexBufferSharedPtr const &)*arg1,arg2,(Ogre::Vector4 const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowCaster_getPointExtrusionDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCaster *arg1 = (Ogre::ShadowCaster *) 0 ;
  Ogre::Light *arg2 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__ShadowCaster, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCaster const *","getPointExtrusionDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCaster * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light const *","getPointExtrusionDistance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  result = (Ogre::Real)((Ogre::ShadowCaster const *)arg1)->getPointExtrusionDistance((Ogre::Light const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMovableObject;

SWIGINTERN void
free_Ogre_MovableObject(Ogre::MovableObject *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MovableObject__notifyCreator(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::MovableObjectFactory *arg2 = (Ogre::MovableObjectFactory *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_notifyCreator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","_notifyCreator", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp2);
  (arg1)->_notifyCreator(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__getCreator(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MovableObjectFactory *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","_getCreator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::MovableObjectFactory *)((Ogre::MovableObject const *)arg1)->_getCreator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__notifyManager(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_notifyManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_notifyManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->_notifyManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","_getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::MovableObject const *)arg1)->_getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::String *) &((Ogre::MovableObject const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::String *) &((Ogre::MovableObject const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getParentNode(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Node *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getParentNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::Node *)((Ogre::MovableObject const *)arg1)->getParentNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getParentSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getParentSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::SceneNode *)((Ogre::MovableObject const *)arg1)->getParentSceneNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_isParentTagPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","isParentTagPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)((Ogre::MovableObject const *)arg1)->isParentTagPoint();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__notifyAttached__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAttached", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAttached(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__notifyAttached__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject__notifyAttached(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_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MovableObject__notifyAttached__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MovableObject__notifyAttached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MovableObject._notifyAttached", 
    "    void MovableObject._notifyAttached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void MovableObject._notifyAttached(Ogre::Node *parent)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_isAttached(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","isAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)((Ogre::MovableObject const *)arg1)->isAttached();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_detachFromParent(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","detachFromParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  (arg1)->detachFromParent();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_isInScene(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","isInScene", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)((Ogre::MovableObject const *)arg1)->isInScene();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__notifyMoved(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_notifyMoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  (arg1)->_notifyMoved();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getWorldBoundingBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getWorldBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getWorldBoundingBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingBox(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getWorldBoundingBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getWorldBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_getWorldBoundingBox(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_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MovableObject_getWorldBoundingBox__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MovableObject_getWorldBoundingBox__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MovableObject.getWorldBoundingBox", 
    "    Ogre::AxisAlignedBox const & MovableObject.getWorldBoundingBox(bool derive)\n"
    "    Ogre::AxisAlignedBox const & MovableObject.getWorldBoundingBox()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getWorldBoundingSphere__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Sphere *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getWorldBoundingSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getWorldBoundingSphere", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Sphere *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingSphere(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getWorldBoundingSphere__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Sphere *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getWorldBoundingSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::Sphere *) &((Ogre::MovableObject const *)arg1)->getWorldBoundingSphere();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_getWorldBoundingSphere(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_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MovableObject_getWorldBoundingSphere__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MovableObject_getWorldBoundingSphere__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MovableObject.getWorldBoundingSphere", 
    "    Ogre::Sphere const & MovableObject.getWorldBoundingSphere(bool derive)\n"
    "    Ogre::Sphere const & MovableObject.getWorldBoundingSphere()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)((Ogre::MovableObject const *)arg1)->getVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)((Ogre::MovableObject const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRenderingDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setRenderingDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getRenderingDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setRenderingMinPixelSize(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setRenderingMinPixelSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRenderingMinPixelSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setRenderingMinPixelSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getRenderingMinPixelSize(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getRenderingMinPixelSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getRenderingMinPixelSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Any *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","setUserAny", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","setUserAny", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  (arg1)->setUserAny((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::Any *) &((Ogre::MovableObject const *)arg1)->getUserAny();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getUserObjectBindings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getUserObjectBindings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::UserObjectBindings *) &((Ogre::MovableObject const *)arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_getUserObjectBindings(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_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MovableObject_getUserObjectBindings__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MovableObject_getUserObjectBindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "MovableObject.getUserObjectBindings", 
    "    Ogre::UserObjectBindings const & MovableObject.getUserObjectBindings()\n"
    "    Ogre::UserObjectBindings const & MovableObject.getUserObjectBindings()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setRenderQueueGroupAndPriority(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setRenderQueueGroupAndPriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroupAndPriority", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setRenderQueueGroupAndPriority", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::uint8)((Ogre::MovableObject const *)arg1)->getRenderQueueGroup();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__getParentNodeFullTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","_getParentNodeFullTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::MovableObject const *)arg1)->_getParentNodeFullTransform();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_addQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","addQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","addQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->addQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_removeQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","removeQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","removeQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->removeQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getQueryFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setDefaultQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::MovableObject::setDefaultQueryFlags", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint32 >(val1);
  Ogre::MovableObject::setDefaultQueryFlags(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getDefaultQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::uint32)Ogre::MovableObject::getDefaultQueryFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setVisibilityFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setVisibilityFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_addVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","addVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","addVisibilityFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->addVisibilityFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_removeVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","removeVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","removeVisibilityFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->removeVisibilityFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getVisibilityFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setDefaultVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::MovableObject::setDefaultVisibilityFlags", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint32 >(val1);
  Ogre::MovableObject::setDefaultVisibilityFlags(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getDefaultVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::uint32)Ogre::MovableObject::getDefaultVisibilityFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::MovableObject::Listener *arg2 = (Ogre::MovableObject::Listener *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject::Listener *","setListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject::Listener * >(argp2);
  (arg1)->setListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MovableObject::Listener *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::MovableObject::Listener *)((Ogre::MovableObject const *)arg1)->getListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject__Listener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_queryLights(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","queryLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::LightList *) &((Ogre::MovableObject const *)arg1)->queryLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getLightMask(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getLightMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getLightMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setLightMask(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setLightMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setLightMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setLightMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject__getLightList(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","_getLightList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::LightList *)(arg1)->_getLightList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::EdgeData *)(arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_hasEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","hasEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)(arg1)->hasEdgeList();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getShadowVolumeRenderableIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  unsigned long arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "unsigned long","getShadowVolumeRenderableIterator", 7, argv[5] ));
  } 
  arg7 = static_cast< unsigned long >(val7);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getShadowVolumeRenderableIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_getShadowVolumeRenderableIterator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_MovableObject_getShadowVolumeRenderableIterator__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MovableObject_getShadowVolumeRenderableIterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "MovableObject.getShadowVolumeRenderableIterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator MovableObject.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator MovableObject.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getLightCapBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getLightCapBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getLightCapBounds();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getDarkCapBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Light *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getDarkCapBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Light,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light const &","getDarkCapBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Light const &","getDarkCapBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","getDarkCapBounds", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::AxisAlignedBox *) &((Ogre::MovableObject const *)arg1)->getDarkCapBounds((Ogre::Light const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setCastShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setCastShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCastShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCastShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getCastShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getCastShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)((Ogre::MovableObject const *)arg1)->getCastShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getReceivesShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","getReceivesShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)(arg1)->getReceivesShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getPointExtrusionDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Light *arg2 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getPointExtrusionDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light const *","getPointExtrusionDistance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  result = (Ogre::Real)((Ogre::MovableObject const *)arg1)->getPointExtrusionDistance((Ogre::Light const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_getTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (Ogre::uint32)((Ogre::MovableObject const *)arg1)->getTypeFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObject_visitRenderables(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_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MovableObject_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MovableObject_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MovableObject.visitRenderables", 
    "    void MovableObject.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void MovableObject.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_setDebugDisplayEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setDebugDisplayEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDebugDisplayEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDebugDisplayEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObject_isDebugDisplayEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObject *arg1 = (Ogre::MovableObject *) 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_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","isDebugDisplayEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObject * >(argp1);
  result = (bool)((Ogre::MovableObject const *)arg1)->isDebugDisplayEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMovableObjectFactory;

SWIGINTERN void
free_Ogre_MovableObjectFactory(Ogre::MovableObjectFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MovableObjectFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectFactory *arg1 = (Ogre::MovableObjectFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::MovableObjectFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectFactory_createInstance__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectFactory *arg1 = (Ogre::MovableObjectFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  Ogre::NameValuePairList *arg4 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::MovableObject *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_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstance", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,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, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createInstance", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::NameValuePairList * >(argp4);
  result = (Ogre::MovableObject *)(arg1)->createInstance((Ogre::String const &)*arg2,arg3,(Ogre::NameValuePairList const *)arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectFactory_createInstance__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectFactory *arg1 = (Ogre::MovableObjectFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::MovableObject *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_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstance", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  result = (Ogre::MovableObject *)(arg1)->createInstance((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovableObjectFactory_createInstance(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_Ogre__MovableObjectFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MovableObjectFactory_createInstance__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovableObjectFactory, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, 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, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MovableObjectFactory_createInstance__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MovableObjectFactory.createInstance", 
    "    Ogre::MovableObject * MovableObjectFactory.createInstance(Ogre::String const &name, Ogre::SceneManager *manager, Ogre::NameValuePairList const *params)\n"
    "    Ogre::MovableObject * MovableObjectFactory.createInstance(Ogre::String const &name, Ogre::SceneManager *manager)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectFactory *arg1 = (Ogre::MovableObjectFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectFactory_requestTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectFactory *arg1 = (Ogre::MovableObjectFactory *) 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_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory const *","requestTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp1);
  result = (bool)((Ogre::MovableObjectFactory const *)arg1)->requestTypeFlags();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectFactory__notifyTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectFactory *arg1 = (Ogre::MovableObjectFactory *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","_notifyTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","_notifyTypeFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned long >(val2);
  (arg1)->_notifyTypeFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectFactory_getTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectFactory *arg1 = (Ogre::MovableObjectFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory const *","getTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp1);
  result = (Ogre::uint32)((Ogre::MovableObjectFactory const *)arg1)->getTypeFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPlaneBoundedVolume;

SWIGINTERN VALUE
_wrap_PlaneBoundedVolume_planes_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolume *arg1 = (Ogre::PlaneBoundedVolume *) 0 ;
  Ogre::PlaneBoundedVolume::PlaneList *arg2 = (Ogre::PlaneBoundedVolume::PlaneList *) 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_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume *","planes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume::PlaneList *","planes", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PlaneBoundedVolume::PlaneList * >(argp2);
  if (arg1) (arg1)->planes = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneBoundedVolume_planes_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolume *arg1 = (Ogre::PlaneBoundedVolume *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PlaneBoundedVolume::PlaneList *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_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume *","planes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp1);
  result = (Ogre::PlaneBoundedVolume::PlaneList *)& ((arg1)->planes);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneBoundedVolume_outside_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolume *arg1 = (Ogre::PlaneBoundedVolume *) 0 ;
  Ogre::Plane::Side arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume *","outside", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Plane::Side","outside", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Plane::Side >(val2);
  if (arg1) (arg1)->outside = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneBoundedVolume_outside_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolume *arg1 = (Ogre::PlaneBoundedVolume *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Plane::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_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume *","outside", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp1);
  result = (Ogre::Plane::Side) ((arg1)->outside);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_PlaneBoundedVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PlaneBoundedVolume";
  Ogre::PlaneBoundedVolume *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PlaneBoundedVolume *)new Ogre::PlaneBoundedVolume();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PlaneBoundedVolume__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane::Side arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PlaneBoundedVolume";
  Ogre::PlaneBoundedVolume *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( "", "Ogre::Plane::Side","Ogre::PlaneBoundedVolume", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Plane::Side >(val1);
  result = (Ogre::PlaneBoundedVolume *)new Ogre::PlaneBoundedVolume(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PlaneBoundedVolume(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_PlaneBoundedVolume__SWIG_0(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_PlaneBoundedVolume__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PlaneBoundedVolume.new", 
    "    PlaneBoundedVolume.new()\n"
    "    PlaneBoundedVolume.new(Ogre::Plane::Side theOutside)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneBoundedVolume_intersects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolume *arg1 = (Ogre::PlaneBoundedVolume *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)((Ogre::PlaneBoundedVolume const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneBoundedVolume_intersects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolume *arg1 = (Ogre::PlaneBoundedVolume *) 0 ;
  Ogre::Sphere *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_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = (bool)((Ogre::PlaneBoundedVolume const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneBoundedVolume_intersects__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolume *arg1 = (Ogre::PlaneBoundedVolume *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  result = (arg1)->intersects((Ogre::Ray const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PlaneBoundedVolume_intersects(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_Ogre__PlaneBoundedVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PlaneBoundedVolume_intersects__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PlaneBoundedVolume_intersects__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PlaneBoundedVolume_intersects__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PlaneBoundedVolume.intersects", 
    "    std::pair< bool,Ogre::Real > PlaneBoundedVolume.intersects(Ogre::AxisAlignedBox const &box)\n"
    "    std::pair< bool,Ogre::Real > PlaneBoundedVolume.intersects(Ogre::Sphere const &sphere)\n"
    "    std::pair< bool,Ogre::Real > PlaneBoundedVolume.intersects(Ogre::Ray const &ray)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_PlaneBoundedVolume(Ogre::PlaneBoundedVolume *arg1) {
    delete arg1;
}

swig_class SwigClassMovablePlane;

SWIGINTERN VALUE
_wrap_new_MovablePlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::MovablePlane";
  Ogre::MovablePlane *result = 0 ;
  
  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 &","Ogre::MovablePlane", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::MovablePlane", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MovablePlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Plane *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MovablePlane";
  Ogre::MovablePlane *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__Plane,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plane const &","Ogre::MovablePlane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","Ogre::MovablePlane", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Plane * >(argp1);
  result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Plane const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MovablePlane__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Real arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MovablePlane";
  Ogre::MovablePlane *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 &","Ogre::MovablePlane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::MovablePlane", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::MovablePlane", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Vector3 const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MovablePlane__SWIG_3(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 = "Ogre::MovablePlane";
  Ogre::MovablePlane *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 &","Ogre::MovablePlane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::MovablePlane", 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 &","Ogre::MovablePlane", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::MovablePlane", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MovablePlane__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MovablePlane";
  Ogre::MovablePlane *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::MovablePlane", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::MovablePlane", 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 &","Ogre::MovablePlane", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::MovablePlane", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","Ogre::MovablePlane", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::MovablePlane", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = (Ogre::MovablePlane *)new Ogre::MovablePlane((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MovablePlane(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MovablePlane__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_new_MovablePlane__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_MovablePlane__SWIG_3(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) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_MovablePlane__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_MovablePlane__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "MovablePlane.new", 
    "    MovablePlane.new(Ogre::String const &name)\n"
    "    MovablePlane.new(Ogre::Plane const &rhs)\n"
    "    MovablePlane.new(Ogre::Vector3 const &rkNormal, Ogre::Real fConstant)\n"
    "    MovablePlane.new(Ogre::Vector3 const &rkNormal, Ogre::Vector3 const &rkPoint)\n"
    "    MovablePlane.new(Ogre::Vector3 const &rkPoint0, Ogre::Vector3 const &rkPoint1, Ogre::Vector3 const &rkPoint2)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_MovablePlane(Ogre::MovablePlane *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MovablePlane__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::MovablePlane const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  result = (Ogre::Real)((Ogre::MovablePlane const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  result = (Ogre::String *) &((Ogre::MovablePlane const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane__getDerivedPlane(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Plane *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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane const *","_getDerivedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  result = (Ogre::Plane *) &((Ogre::MovablePlane const *)arg1)->_getDerivedPlane();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovablePlane_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MovablePlane_visitRenderables(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_Ogre__MovablePlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MovablePlane_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MovablePlane, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MovablePlane_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MovablePlane.visitRenderables", 
    "    void MovablePlane.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void MovablePlane.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


swig_class SwigClassShadowCameraSetup;

SWIGINTERN VALUE
_wrap_ShadowCameraSetup_getShadowCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowCameraSetup *arg1 = (Ogre::ShadowCameraSetup *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Light *arg5 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg6 = (Ogre::Camera *) 0 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowCameraSetup const *","getShadowCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowCameraSetup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getShadowCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getShadowCamera", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCamera", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Light * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Camera *","getShadowCamera", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Camera * >(argp6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","getShadowCamera", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ((Ogre::ShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ShadowCameraSetup(Ogre::ShadowCameraSetup *arg1) {
    delete arg1;
}

swig_class SwigClassDefaultShadowCameraSetup;

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

SWIGINTERN VALUE
_wrap_new_DefaultShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DefaultShadowCameraSetup";
  Ogre::DefaultShadowCameraSetup *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DefaultShadowCameraSetup *)new Ogre::DefaultShadowCameraSetup();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultShadowCameraSetup(Ogre::DefaultShadowCameraSetup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultShadowCameraSetup_getShadowCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultShadowCameraSetup *arg1 = (Ogre::DefaultShadowCameraSetup *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Light *arg5 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg6 = (Ogre::Camera *) 0 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__DefaultShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultShadowCameraSetup const *","getShadowCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultShadowCameraSetup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getShadowCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getShadowCamera", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCamera", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Light * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Camera *","getShadowCamera", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Camera * >(argp6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","getShadowCamera", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ((Ogre::DefaultShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassLight;

SWIGINTERN VALUE
_wrap_Light_tempSquareDist_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","tempSquareDist", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","tempSquareDist", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->tempSquareDist = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_tempSquareDist_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","tempSquareDist", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real) ((arg1)->tempSquareDist);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__calcTempSquareDist(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Vector3 *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","_calcTempSquareDist", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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 &","_calcTempSquareDist", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","_calcTempSquareDist", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->_calcTempSquareDist((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Light__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Light";
  Ogre::Light *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Light *)new Ogre::Light();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Light__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Light";
  Ogre::Light *result = 0 ;
  
  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 &","Ogre::Light", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Light", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Light *)new Ogre::Light((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Light(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_Light__SWIG_0(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_new_Light__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Light.new", 
    "    Light.new()\n"
    "    Light.new(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Light(Ogre::Light *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Light_setType(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Light::LightTypes arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Light::LightTypes","setType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Light::LightTypes >(val2);
  (arg1)->setType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Light::LightTypes 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Light::LightTypes)((Ogre::Light const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setDiffuseColour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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 ;
  
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setDiffuseColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDiffuseColour", 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","setDiffuseColour", 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","setDiffuseColour", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setDiffuseColour(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setDiffuseColour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::ColourValue *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setDiffuseColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setDiffuseColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setDiffuseColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setDiffuseColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_setDiffuseColour(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_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Light_setDiffuseColour__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 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_Light_setDiffuseColour__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.setDiffuseColour", 
    "    void Light.setDiffuseColour(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Light.setDiffuseColour(Ogre::ColourValue const &colour)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getDiffuseColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getDiffuseColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Light const *)arg1)->getDiffuseColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpecularColour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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 ;
  
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpecularColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpecularColour", 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","setSpecularColour", 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","setSpecularColour", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setSpecularColour(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpecularColour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::ColourValue *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpecularColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSpecularColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSpecularColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setSpecularColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_setSpecularColour(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_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Light_setSpecularColour__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 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_Light_setSpecularColour__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.setSpecularColour", 
    "    void Light.setSpecularColour(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Light.setSpecularColour(Ogre::ColourValue const &colour)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getSpecularColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getSpecularColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Light const *)arg1)->getSpecularColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setAttenuation(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setAttenuation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setAttenuation", 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","setAttenuation", 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","setAttenuation", 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","setAttenuation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setAttenuation(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getAttenuationRange(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getAttenuationRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationRange();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getAttenuationConstant(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getAttenuationConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationConstant();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getAttenuationLinear(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getAttenuationLinear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationLinear();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getAttenuationQuadric(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getAttenuationQuadric", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getAttenuationQuadric();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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 ;
  
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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);
  (arg1)->setPosition(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Vector3 *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_setPosition(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_Ogre__Light, 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_Light_setPosition__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 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_Light_setPosition__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.setPosition", 
    "    void Light.setPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Light.setPosition(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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 ;
  
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDirection", 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","setDirection", 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","setDirection", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setDirection(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Vector3 *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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 &","setDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_setDirection(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_Ogre__Light, 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_Light_setDirection__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 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_Light_setDirection__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.setDirection", 
    "    void Light.setDirection(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Light.setDirection(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpotlightRange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpotlightRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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 const &","setSpotlightRange", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setSpotlightRange", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","setSpotlightRange", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setSpotlightRange", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSpotlightRange", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setSpotlightRange((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpotlightRange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Radian *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpotlightRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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 const &","setSpotlightRange", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setSpotlightRange", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","setSpotlightRange", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setSpotlightRange", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  (arg1)->setSpotlightRange((Ogre::Radian const &)*arg2,(Ogre::Radian const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_setSpotlightRange(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_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Light_setSpotlightRange__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Light_setSpotlightRange__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Light.setSpotlightRange", 
    "    void Light.setSpotlightRange(Ogre::Radian const &innerAngle, Ogre::Radian const &outerAngle, Ogre::Real falloff)\n"
    "    void Light.setSpotlightRange(Ogre::Radian const &innerAngle, Ogre::Radian const &outerAngle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getSpotlightInnerAngle(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getSpotlightInnerAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Radian *) &((Ogre::Light const *)arg1)->getSpotlightInnerAngle();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getSpotlightOuterAngle(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getSpotlightOuterAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Radian *) &((Ogre::Light const *)arg1)->getSpotlightOuterAngle();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getSpotlightFalloff(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getSpotlightFalloff", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getSpotlightFalloff();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpotlightInnerAngle(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Radian *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpotlightInnerAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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 const &","setSpotlightInnerAngle", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setSpotlightInnerAngle", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setSpotlightInnerAngle((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpotlightOuterAngle(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Radian *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpotlightOuterAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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 const &","setSpotlightOuterAngle", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setSpotlightOuterAngle", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setSpotlightOuterAngle((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpotlightFalloff(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpotlightFalloff", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpotlightFalloff", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSpotlightFalloff(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setSpotlightNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setSpotlightNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpotlightNearClipDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSpotlightNearClipDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getSpotlightNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getSpotlightNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getSpotlightNearClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setPowerScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setPowerScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPowerScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setPowerScale(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getPowerScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getPowerScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getPowerScale();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__notifyAttached__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAttached", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAttached(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__notifyAttached__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light__notifyAttached(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_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Light__notifyAttached__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Light__notifyAttached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Light._notifyAttached", 
    "    void Light._notifyAttached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void Light._notifyAttached(Ogre::Node *parent)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__notifyMoved(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","_notifyMoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  (arg1)->_notifyMoved();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::Light const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::String *) &((Ogre::Light const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getDerivedPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getDerivedPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getDerivedPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDerivedPosition(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getDerivedPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getDerivedPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDerivedPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_getDerivedPosition(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_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Light_getDerivedPosition__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Light_getDerivedPosition__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Light.getDerivedPosition", 
    "    Ogre::Vector3 const & Light.getDerivedPosition(bool cameraRelativeIfSet)\n"
    "    Ogre::Vector3 const & Light.getDerivedPosition()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getDerivedDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getDerivedDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Light const *)arg1)->getDerivedDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getAs4DVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getAs4DVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getAs4DVector", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = ((Ogre::Light const *)arg1)->getAs4DVector(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getAs4DVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getAs4DVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = ((Ogre::Light const *)arg1)->getAs4DVector();
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_getAs4DVector(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_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Light_getAs4DVector__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Light_getAs4DVector__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Light.getAs4DVector", 
    "    Ogre::Vector4 Light.getAs4DVector(bool cameraRelativeIfSet)\n"
    "    Ogre::Vector4 Light.getAs4DVector()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__getNearClipVolume(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) (Ogre::Camera *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::PlaneBoundedVolume *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","_getNearClipVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *const","_getNearClipVolume", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::PlaneBoundedVolume *) &((Ogre::Light const *)arg1)->_getNearClipVolume((Ogre::Camera const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__getFrustumClipVolumes(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) (Ogre::Camera *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::PlaneBoundedVolumeList *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","_getFrustumClipVolumes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *const","_getFrustumClipVolumes", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::PlaneBoundedVolumeList *) &((Ogre::Light const *)arg1)->_getFrustumClipVolumes((Ogre::Camera const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::uint32)((Ogre::Light const *)arg1)->getTypeFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_createAnimableValue(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::AnimableValue > > 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","createAnimableValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(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( "", "Ogre::String const &","createAnimableValue", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimableValue", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->createAnimableValue((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::AnimableValuePtr(static_cast< const Ogre::AnimableValuePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AnimableValue_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setCustomShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::ShadowCameraSetupPtr *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setCustomShadowCameraSetup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ShadowCameraSetupPtr const &","setCustomShadowCameraSetup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ShadowCameraSetupPtr const &","setCustomShadowCameraSetup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ShadowCameraSetupPtr * >(argp2);
  (arg1)->setCustomShadowCameraSetup((Ogre::ShadowCameraSetupPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_resetCustomShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","resetCustomShadowCameraSetup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  (arg1)->resetCustomShadowCameraSetup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getCustomShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ShadowCameraSetupPtr *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getCustomShadowCameraSetup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::ShadowCameraSetupPtr *) &((Ogre::Light const *)arg1)->getCustomShadowCameraSetup();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Light_visitRenderables(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_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Light_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Light, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Light_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Light.visitRenderables", 
    "    void Light.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void Light.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__getIndexInFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","_getIndexInFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = ((Ogre::Light const *)arg1)->_getIndexInFrame();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__notifyIndexInFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","_notifyIndexInFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_notifyIndexInFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->_notifyIndexInFrame(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setShadowFarDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setShadowFarDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowFarDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowFarDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_resetShadowFarDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","resetShadowFarDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  (arg1)->resetShadowFarDistance();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getShadowFarDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowFarDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowFarDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getShadowFarDistanceSquared(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowFarDistanceSquared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowFarDistanceSquared();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setShadowNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setShadowNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowNearClipDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowNearClipDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getShadowNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowNearClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__deriveShadowNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","_deriveShadowNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","_deriveShadowNearClipDistance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->_deriveShadowNearClipDistance((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setShadowFarClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setShadowFarClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowFarClipDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowFarClipDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getShadowFarClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowFarClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->getShadowFarClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__deriveShadowFarClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","_deriveShadowFarClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","_deriveShadowFarClipDistance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::Light const *)arg1)->_deriveShadowFarClipDistance((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__setCameraRelative(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","_setCameraRelative", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_setCameraRelative", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_setCameraRelative(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_setCustomParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::Vector4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light *","setCustomParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setCustomParameter", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","setCustomParameter", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","setCustomParameter", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  (arg1)->setCustomParameter(arg2,(Ogre::Vector4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light_getCustomParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 *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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","getCustomParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","getCustomParameter", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  result = (Ogre::Vector4 *) &((Ogre::Light const *)arg1)->getCustomParameter(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Light__updateCustomGpuParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::Light *arg1 = (Ogre::Light *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::GpuProgramParameters::AutoConstantEntry *arg3 = 0 ;
  Ogre::GpuProgramParameters *arg4 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Light const *","_updateCustomGpuParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Light * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","_updateCustomGpuParameter", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantEntry,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantEntry const &","_updateCustomGpuParameter", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParameters::AutoConstantEntry const &","_updateCustomGpuParameter", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::GpuProgramParameters::AutoConstantEntry * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_updateCustomGpuParameter", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp4);
  ((Ogre::Light const *)arg1)->_updateCustomGpuParameter(arg2,(Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassLightFactory;

SWIGINTERN void
free_Ogre_LightFactory(Ogre::LightFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LightFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::LightFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_LightFactory_FACTORY_TYPE_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::LightFactory::FACTORY_TYPE_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::LightFactory::FACTORY_TYPE_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LightFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::LightFactory *arg1 = (Ogre::LightFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__LightFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LightFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LightFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::LightFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LightFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::LightFactory *arg1 = (Ogre::LightFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__LightFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LightFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LightFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassAutoParamDataSource;

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

SWIGINTERN VALUE
_wrap_new_AutoParamDataSource(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::AutoParamDataSource";
  Ogre::AutoParamDataSource *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::AutoParamDataSource *)new Ogre::AutoParamDataSource();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AutoParamDataSource(Ogre::AutoParamDataSource *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AutoParamDataSource_setCurrentRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setCurrentRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable const *","setCurrentRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  (arg1)->setCurrentRenderable((Ogre::Renderable const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setWorldMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setWorldMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","setWorldMatrices", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setWorldMatrices", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setWorldMatrices((Ogre::Matrix4 const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","setCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setCurrentCamera", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setCurrentCamera((Ogre::Camera const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setCurrentLightList(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::LightList *arg2 = (Ogre::LightList *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setCurrentLightList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LightList const *","setCurrentLightList", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LightList * >(argp2);
  (arg1)->setCurrentLightList((Ogre::LightList const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setTextureProjector(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Frustum *arg2 = (Ogre::Frustum *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setTextureProjector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Frustum const *","setTextureProjector", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Frustum * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setTextureProjector", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setTextureProjector((Ogre::Frustum const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setCurrentRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setCurrentRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","setCurrentRenderTarget", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  (arg1)->setCurrentRenderTarget((Ogre::RenderTarget const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setCurrentViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setCurrentViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport const *","setCurrentViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->setCurrentViewport((Ogre::Viewport const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setShadowDirLightExtrusionDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setShadowDirLightExtrusionDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowDirLightExtrusionDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowDirLightExtrusionDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setMainCamBoundsInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::VisibleObjectsBoundsInfo *arg2 = (Ogre::VisibleObjectsBoundsInfo *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setMainCamBoundsInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","setMainCamBoundsInfo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp2);
  (arg1)->setMainCamBoundsInfo(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setCurrentSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setCurrentSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","setCurrentSceneManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->setCurrentSceneManager((Ogre::SceneManager const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setCurrentPass(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setCurrentPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass const *","setCurrentPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  (arg1)->setCurrentPass((Ogre::Pass const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getWorldMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getWorldMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getWorldMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getWorldMatrixArray(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getWorldMatrixArray", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *)((Ogre::AutoParamDataSource const *)arg1)->getWorldMatrixArray();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getWorldMatrixCount(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getWorldMatrixCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getWorldMatrixCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getViewMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getViewProjectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getViewProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getViewProjectionMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getProjectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getProjectionMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getWorldViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getWorldViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getWorldViewProjMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getWorldViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getWorldViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getWorldViewMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseWorldMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseWorldMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseWorldMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseWorldViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseWorldViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseWorldViewMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseViewMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseTransposeWorldMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseTransposeWorldMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeWorldMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseTransposeWorldViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseTransposeWorldViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeWorldViewMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCameraPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCameraPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getCameraPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCameraPositionObjectSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCameraPositionObjectSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getCameraPositionObjectSpace();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLodCameraPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLodCameraPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getLodCameraPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLodCameraPositionObjectSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLodCameraPositionObjectSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getLodCameraPositionObjectSpace();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_hasLightList(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","hasLightList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (bool)((Ogre::AutoParamDataSource const *)arg1)->hasLightList();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightNumber", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float)((Ogre::AutoParamDataSource const *)arg1)->getLightNumber(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightCount(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (float)((Ogre::AutoParamDataSource const *)arg1)->getLightCount();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightCastsShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightCastsShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightCastsShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (float)((Ogre::AutoParamDataSource const *)arg1)->getLightCastsShadows(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightDiffuseColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightDiffuseColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightDiffuseColour", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getLightDiffuseColour(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightSpecularColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightSpecularColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightSpecularColour", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getLightSpecularColour(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightDiffuseColourWithPower(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightDiffuseColourWithPower", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightDiffuseColourWithPower", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getLightDiffuseColourWithPower(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightSpecularColourWithPower(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightSpecularColourWithPower", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightSpecularColourWithPower", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getLightSpecularColourWithPower(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Vector3 *) &((Ogre::AutoParamDataSource const *)arg1)->getLightPosition(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightAs4DVector(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightAs4DVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightAs4DVector", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getLightAs4DVector(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightDirection", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Vector3 *) &((Ogre::AutoParamDataSource const *)arg1)->getLightDirection(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightPowerScale(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightPowerScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightPowerScale", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getLightPowerScale(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getLightAttenuation(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getLightAttenuation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getLightAttenuation", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getLightAttenuation(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSpotlightParams(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSpotlightParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getSpotlightParams", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getSpotlightParams(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setAmbientLightColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setAmbientLightColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setAmbientLightColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setAmbientLightColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setAmbientLightColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getAmbientLightColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getAmbientLightColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getAmbientLightColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSurfaceAmbientColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSurfaceAmbientColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceAmbientColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSurfaceDiffuseColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSurfaceDiffuseColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceDiffuseColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSurfaceSpecularColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSurfaceSpecularColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceSpecularColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSurfaceEmissiveColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSurfaceEmissiveColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getSurfaceEmissiveColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSurfaceShininess(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSurfaceShininess", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSurfaceShininess();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getDerivedAmbientLightColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getDerivedAmbientLightColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getDerivedAmbientLightColour();
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getDerivedSceneColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getDerivedSceneColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getDerivedSceneColour();
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setFog(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 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","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getFogColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getFogColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getFogColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getFogParams(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getFogParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getFogParams();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTextureViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTextureViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getTextureViewProjMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getTextureViewProjMatrix(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTextureWorldViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTextureWorldViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getTextureWorldViewProjMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getTextureWorldViewProjMatrix(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSpotlightViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSpotlightViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getSpotlightViewProjMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getSpotlightViewProjMatrix(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSpotlightWorldViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSpotlightWorldViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getSpotlightWorldViewProjMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getSpotlightWorldViewProjMatrix(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTextureTransformMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTextureTransformMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getTextureTransformMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Matrix4 *) &((Ogre::AutoParamDataSource const *)arg1)->getTextureTransformMatrix(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCurrentRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderTarget *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCurrentRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::RenderTarget *)((Ogre::AutoParamDataSource const *)arg1)->getCurrentRenderTarget();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCurrentRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Renderable *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCurrentRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Renderable *)((Ogre::AutoParamDataSource const *)arg1)->getCurrentRenderable();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCurrentPass(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pass *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCurrentPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Pass *)((Ogre::AutoParamDataSource const *)arg1)->getCurrentPass();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTextureSize(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTextureSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getTextureSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTextureSize(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseTextureSize(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseTextureSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getInverseTextureSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTextureSize(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getPackedTextureSize(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getPackedTextureSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getPackedTextureSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getPackedTextureSize(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getShadowExtrusionDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getShadowExtrusionDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getShadowExtrusionDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSceneDepthRange(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Vector4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSceneDepthRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getSceneDepthRange();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getShadowSceneDepthRange(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getShadowSceneDepthRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getShadowSceneDepthRange", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Vector4 *) &((Ogre::AutoParamDataSource const *)arg1)->getShadowSceneDepthRange(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getShadowColour(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getShadowColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::AutoParamDataSource const *)arg1)->getShadowColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseViewProjMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseTransposeViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseTransposeViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeViewProjMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTransposeViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTransposeViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeViewProjMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTransposeViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTransposeViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeViewMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseTransposeViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseTransposeViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeViewMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTransposeProjectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTransposeProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeProjectionMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseProjectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseProjectionMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseTransposeProjectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseTransposeProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeProjectionMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTransposeWorldViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTransposeWorldViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeWorldViewProjMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseWorldViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseWorldViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseWorldViewProjMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseTransposeWorldViewProjMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseTransposeWorldViewProjMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getInverseTransposeWorldViewProjMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTransposeWorldViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTransposeWorldViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeWorldViewMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTransposeWorldMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTransposeWorldMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTransposeWorldMatrix();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTime(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTime_0_X(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTime_0_X", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTime_0_X", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime_0_X(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCosTime_0_X(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCosTime_0_X", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCosTime_0_X", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getCosTime_0_X(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSinTime_0_X(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSinTime_0_X", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getSinTime_0_X", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSinTime_0_X(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTanTime_0_X(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTanTime_0_X", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTanTime_0_X", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTanTime_0_X(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTime_0_X_packed(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTime_0_X_packed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTime_0_X_packed", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTime_0_X_packed(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTime_0_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTime_0_1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTime_0_1", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime_0_1(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCosTime_0_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCosTime_0_1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCosTime_0_1", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getCosTime_0_1(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSinTime_0_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSinTime_0_1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getSinTime_0_1", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSinTime_0_1(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTanTime_0_1(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTanTime_0_1", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTanTime_0_1", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTanTime_0_1(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTime_0_1_packed(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTime_0_1_packed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTime_0_1_packed", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTime_0_1_packed(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTime_0_2Pi(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTime_0_2Pi", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTime_0_2Pi", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTime_0_2Pi(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getCosTime_0_2Pi(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getCosTime_0_2Pi", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCosTime_0_2Pi", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getCosTime_0_2Pi(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getSinTime_0_2Pi(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getSinTime_0_2Pi", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getSinTime_0_2Pi", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getSinTime_0_2Pi(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTanTime_0_2Pi(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTanTime_0_2Pi", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTanTime_0_2Pi", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getTanTime_0_2Pi(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getTime_0_2Pi_packed(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Vector4 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getTime_0_2Pi_packed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTime_0_2Pi_packed", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getTime_0_2Pi_packed(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getFrameTime(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getFrameTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFrameTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getFPS(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getFPS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFPS();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getViewportWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getViewportWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getViewportWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getViewportHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getViewportHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getViewportHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseViewportWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseViewportWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getInverseViewportWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getInverseViewportHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getInverseViewportHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getInverseViewportHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getViewDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getViewDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getViewDirection();
  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_AutoParamDataSource_getViewSideVector(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getViewSideVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getViewSideVector();
  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_AutoParamDataSource_getViewUpVector(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getViewUpVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = ((Ogre::AutoParamDataSource const *)arg1)->getViewUpVector();
  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_AutoParamDataSource_getFOV(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getFOV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFOV();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getNearClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getFarClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getFarClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (Ogre::Real)((Ogre::AutoParamDataSource const *)arg1)->getFarClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_getPassNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","getPassNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  result = (int)((Ogre::AutoParamDataSource const *)arg1)->getPassNumber();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_setPassNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","setPassNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setPassNumber", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setPassNumber(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_incPassNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource *","incPassNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  (arg1)->incPassNumber();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AutoParamDataSource_updateLightCustomGpuParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::AutoParamDataSource *arg1 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::GpuProgramParameters::AutoConstantEntry *arg2 = 0 ;
  Ogre::GpuProgramParameters *arg3 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","updateLightCustomGpuParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantEntry const &","updateLightCustomGpuParameter", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParameters::AutoConstantEntry const &","updateLightCustomGpuParameter", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramParameters::AutoConstantEntry * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","updateLightCustomGpuParameter", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp3);
  ((Ogre::AutoParamDataSource const *)arg1)->updateLightCustomGpuParameter((Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassBillboard;

SWIGINTERN VALUE
_wrap_Billboard_mPosition_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","mPosition", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  if (arg1) (arg1)->mPosition = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mPosition_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::Vector3 *)& ((arg1)->mPosition);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mDirection_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","mDirection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  if (arg1) (arg1)->mDirection = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mDirection_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::Vector3 *)& ((arg1)->mDirection);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mParentSet_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::BillboardSet *arg2 = (Ogre::BillboardSet *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mParentSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__BillboardSet, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","mParentSet", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::BillboardSet * >(argp2);
  if (arg1) (arg1)->mParentSet = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mParentSet_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardSet *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mParentSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::BillboardSet *) ((arg1)->mParentSet);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mColour_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::ColourValue *arg2 = (Ogre::ColourValue *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue *","mColour", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  if (arg1) (arg1)->mColour = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mColour_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::ColourValue *)& ((arg1)->mColour);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mRotation_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::Radian *arg2 = (Ogre::Radian *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian *","mRotation", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  if (arg1) (arg1)->mRotation = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_mRotation_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","mRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::Radian *)& ((arg1)->mRotation);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Billboard__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Billboard";
  Ogre::Billboard *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Billboard *)new Ogre::Billboard();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Billboard(Ogre::Billboard *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_new_Billboard__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::BillboardSet *arg2 = (Ogre::BillboardSet *) 0 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Billboard";
  Ogre::Billboard *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Billboard", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Billboard", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","Ogre::Billboard", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::BillboardSet * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","Ogre::Billboard", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","Ogre::Billboard", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  result = (Ogre::Billboard *)new Ogre::Billboard((Ogre::Vector3 const &)*arg1,arg2,(Ogre::ColourValue const &)*arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Billboard__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  Ogre::BillboardSet *arg2 = (Ogre::BillboardSet *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Billboard";
  Ogre::Billboard *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 &","Ogre::Billboard", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Billboard", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","Ogre::Billboard", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::BillboardSet * >(argp2);
  result = (Ogre::Billboard *)new Ogre::Billboard((Ogre::Vector3 const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Billboard(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_Billboard__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__BillboardSet, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Billboard__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    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__BillboardSet, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Billboard__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Billboard.new", 
    "    Billboard.new()\n"
    "    Billboard.new(Ogre::Vector3 const &position, Ogre::BillboardSet *owner, Ogre::ColourValue const &colour)\n"
    "    Billboard.new(Ogre::Vector3 const &position, Ogre::BillboardSet *owner)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_getRotation(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","getRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::Radian *) &((Ogre::Billboard const *)arg1)->getRotation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setRotation(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::Radian *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(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 const &","setRotation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setRotation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setRotation((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::Vector3 *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(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);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 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 ;
  
  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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(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);
  (arg1)->setPosition(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Billboard_setPosition(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_Ogre__Billboard, 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_Billboard_setPosition__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Billboard, 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_Billboard_setPosition__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Billboard.setPosition", 
    "    void Billboard.setPosition(Ogre::Vector3 const &position)\n"
    "    void Billboard.setPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_getPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Billboard const *)arg1)->getPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDimensions", 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","setDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_resetDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","resetDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  (arg1)->resetDimensions();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::ColourValue *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_getColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","getColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Billboard const *)arg1)->getColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_hasOwnDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","hasOwnDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (bool)((Ogre::Billboard const *)arg1)->hasOwnDimensions();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_getOwnWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","getOwnWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::Real)((Ogre::Billboard const *)arg1)->getOwnWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_getOwnHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","getOwnHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::Real)((Ogre::Billboard const *)arg1)->getOwnHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard__notifyOwner(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::BillboardSet *arg2 = (Ogre::BillboardSet *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","_notifyOwner", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","_notifyOwner", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::BillboardSet * >(argp2);
  (arg1)->_notifyOwner(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_isUseTexcoordRect(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","isUseTexcoordRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (bool)((Ogre::Billboard const *)arg1)->isUseTexcoordRect();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setTexcoordIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setTexcoordIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setTexcoordIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setTexcoordIndex(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_getTexcoordIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","getTexcoordIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::uint16)((Ogre::Billboard const *)arg1)->getTexcoordIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setTexcoordRect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::FloatRect *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setTexcoordRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_float_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FloatRect const &","setTexcoordRect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FloatRect const &","setTexcoordRect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FloatRect * >(argp2);
  (arg1)->setTexcoordRect((Ogre::FloatRect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_setTexcoordRect__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard *","setTexcoordRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTexcoordRect", 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","setTexcoordRect", 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","setTexcoordRect", 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","setTexcoordRect", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setTexcoordRect(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Billboard_setTexcoordRect(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_Ogre__Billboard, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TRectT_float_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Billboard_setTexcoordRect__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Billboard, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Billboard_setTexcoordRect__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Billboard.setTexcoordRect", 
    "    void Billboard.setTexcoordRect(Ogre::FloatRect const &texcoordRect)\n"
    "    void Billboard.setTexcoordRect(Ogre::Real u0, Ogre::Real v0, Ogre::Real u1, Ogre::Real v1)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Billboard_getTexcoordRect(int argc, VALUE *argv, VALUE self) {
  Ogre::Billboard *arg1 = (Ogre::Billboard *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::FloatRect *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_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Billboard const *","getTexcoordRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Billboard * >(argp1);
  result = (Ogre::FloatRect *) &((Ogre::Billboard const *)arg1)->getTexcoordRect();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassBillboardChain;

SWIGINTERN VALUE
_wrap_new_BillboardChain__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BillboardChain";
  Ogre::BillboardChain *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",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 &","Ogre::BillboardChain", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardChain", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::BillboardChain", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::BillboardChain", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::BillboardChain", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BillboardChain__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  bool arg4 ;
  bool arg5 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BillboardChain";
  Ogre::BillboardChain *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",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 &","Ogre::BillboardChain", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardChain", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::BillboardChain", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::BillboardChain", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BillboardChain__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BillboardChain";
  Ogre::BillboardChain *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::BillboardChain", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardChain", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::BillboardChain", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BillboardChain__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BillboardChain";
  Ogre::BillboardChain *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::BillboardChain", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardChain", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BillboardChain__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BillboardChain";
  Ogre::BillboardChain *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::BillboardChain", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardChain", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::BillboardChain", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_BillboardChain__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::BillboardChain";
  Ogre::BillboardChain *result = 0 ;
  
  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 &","Ogre::BillboardChain", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardChain", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::BillboardChain *)new Ogre::BillboardChain((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BillboardChain(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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BillboardChain__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_BillboardChain__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BillboardChain__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_BillboardChain__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_BillboardChain__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_BillboardChain__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "BillboardChain.new", 
    "    BillboardChain.new(Ogre::String const &name, size_t maxElements, size_t numberOfChains, bool useTextureCoords, bool useColours, bool dynamic)\n"
    "    BillboardChain.new(Ogre::String const &name, size_t maxElements, size_t numberOfChains, bool useTextureCoords, bool useColours)\n"
    "    BillboardChain.new(Ogre::String const &name, size_t maxElements, size_t numberOfChains, bool useTextureCoords)\n"
    "    BillboardChain.new(Ogre::String const &name, size_t maxElements, size_t numberOfChains)\n"
    "    BillboardChain.new(Ogre::String const &name, size_t maxElements)\n"
    "    BillboardChain.new(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_BillboardChain(Ogre::BillboardChain *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BillboardChain_setMaxChainElements(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setMaxChainElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setMaxChainElements", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setMaxChainElements(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getMaxChainElements(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getMaxChainElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = ((Ogre::BillboardChain const *)arg1)->getMaxChainElements();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setNumberOfChains(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setNumberOfChains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setNumberOfChains", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setNumberOfChains(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getNumberOfChains(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getNumberOfChains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = ((Ogre::BillboardChain const *)arg1)->getNumberOfChains();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setUseTextureCoords(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setUseTextureCoords", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseTextureCoords", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseTextureCoords(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getUseTextureCoords(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getUseTextureCoords", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (bool)((Ogre::BillboardChain const *)arg1)->getUseTextureCoords();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setTextureCoordDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::BillboardChain::TexCoordDirection arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setTextureCoordDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BillboardChain::TexCoordDirection","setTextureCoordDirection", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BillboardChain::TexCoordDirection >(val2);
  (arg1)->setTextureCoordDirection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getTextureCoordDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardChain::TexCoordDirection 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","getTextureCoordDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::BillboardChain::TexCoordDirection)(arg1)->getTextureCoordDirection();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setOtherTextureCoordRange(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setOtherTextureCoordRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOtherTextureCoordRange", 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","setOtherTextureCoordRange", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setOtherTextureCoordRange(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getOtherTextureCoordRange(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getOtherTextureCoordRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::Real *)((Ogre::BillboardChain const *)arg1)->getOtherTextureCoordRange();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setUseVertexColours(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setUseVertexColours", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseVertexColours", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseVertexColours(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getUseVertexColours(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getUseVertexColours", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (bool)((Ogre::BillboardChain const *)arg1)->getUseVertexColours();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setDynamic(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setDynamic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDynamic", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDynamic(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getDynamic(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getDynamic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (bool)((Ogre::BillboardChain const *)arg1)->getDynamic();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_addChainElement(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  Ogre::BillboardChain::Element *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","addChainElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","addChainElement", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__BillboardChain__Element,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::BillboardChain::Element const &","addChainElement", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::BillboardChain::Element const &","addChainElement", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::BillboardChain::Element * >(argp3);
  (arg1)->addChainElement(arg2,(Ogre::BillboardChain::Element const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_removeChainElement(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","removeChainElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removeChainElement", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removeChainElement(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_updateChainElement(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::BillboardChain::Element *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","updateChainElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","updateChainElement", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","updateChainElement", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__BillboardChain__Element,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::BillboardChain::Element const &","updateChainElement", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::BillboardChain::Element const &","updateChainElement", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::BillboardChain::Element * >(argp4);
  (arg1)->updateChainElement(arg2,arg3,(Ogre::BillboardChain::Element const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getChainElement(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::BillboardChain::Element *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getChainElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getChainElement", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getChainElement", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::BillboardChain::Element *) &((Ogre::BillboardChain const *)arg1)->getChainElement(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardChain__Element, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getNumChainElements(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getNumChainElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getNumChainElements", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::BillboardChain const *)arg1)->getNumChainElements(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_clearChain(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","clearChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","clearChain", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->clearChain(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_clearAllChains(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","clearAllChains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  (arg1)->clearAllChains();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setFaceCamera__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  bool arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setFaceCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFaceCamera", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(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 &","setFaceCamera", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setFaceCamera", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->setFaceCamera(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setFaceCamera__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setFaceCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFaceCamera", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFaceCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardChain_setFaceCamera(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_Ogre__BillboardChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BillboardChain_setFaceCamera__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_BillboardChain_setFaceCamera__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardChain.setFaceCamera", 
    "    void BillboardChain.setFaceCamera(bool faceCamera, Ogre::Vector3 const &normalVector)\n"
    "    void BillboardChain.setFaceCamera(bool faceCamera)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardChain const *)arg1)->getMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setMaterialName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_setMaterialName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardChain_setMaterialName(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_Ogre__BillboardChain, 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_BillboardChain_setMaterialName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardChain, 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_BillboardChain_setMaterialName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardChain.setMaterialName", 
    "    void BillboardChain.setMaterialName(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void BillboardChain.setMaterialName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::BillboardChain const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::Real)((Ogre::BillboardChain const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::BillboardChain const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::BillboardChain const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardChain const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::RenderOperation *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::BillboardChain const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  result = (Ogre::LightList *) &((Ogre::BillboardChain const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChain_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChain *arg1 = (Ogre::BillboardChain *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardChain_visitRenderables(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_Ogre__BillboardChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BillboardChain_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BillboardChain_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardChain.visitRenderables", 
    "    void BillboardChain.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BillboardChain.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


swig_class SwigClassBillboardChainFactory;

SWIGINTERN void
free_Ogre_BillboardChainFactory(Ogre::BillboardChainFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BillboardChainFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::BillboardChainFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_BillboardChainFactory_FACTORY_TYPE_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::BillboardChainFactory::FACTORY_TYPE_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::BillboardChainFactory::FACTORY_TYPE_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChainFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChainFactory *arg1 = (Ogre::BillboardChainFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardChainFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChainFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChainFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardChainFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardChainFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardChainFactory *arg1 = (Ogre::BillboardChainFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__BillboardChainFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardChainFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardChainFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassParticleSystemRenderer;

SWIGINTERN void
free_Ogre_ParticleSystemRenderer(Ogre::ParticleSystemRenderer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleSystemRenderer const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 0 ;
  Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__listT_Ogre__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_updateRenderQueue", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_updateRenderQueue", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_updateRenderQueue", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_updateRenderQueue(arg2,*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::MaterialPtr *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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr &","_setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr &","_setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->_setMaterial(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyAttached__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAttached", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAttached(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyAttached__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemRenderer__notifyAttached(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_Ogre__ParticleSystemRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleSystemRenderer__notifyAttached__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleSystemRenderer__notifyAttached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystemRenderer._notifyAttached", 
    "    void ParticleSystemRenderer._notifyAttached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void ParticleSystemRenderer._notifyAttached(Ogre::Node *parent)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyParticleRotated(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyParticleRotated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  (arg1)->_notifyParticleRotated();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyParticleResized(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyParticleResized", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  (arg1)->_notifyParticleResized();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyParticleQuota(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyParticleQuota", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_notifyParticleQuota", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->_notifyParticleQuota(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyDefaultDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyDefaultDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_notifyDefaultDimensions", 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","_notifyDefaultDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->_notifyDefaultDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyParticleEmitted(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Particle *arg2 = (Ogre::Particle *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyParticleEmitted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Particle *","_notifyParticleEmitted", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Particle * >(argp2);
  (arg1)->_notifyParticleEmitted(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyParticleExpired(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Particle *arg2 = (Ogre::Particle *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyParticleExpired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Particle *","_notifyParticleExpired", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Particle * >(argp2);
  (arg1)->_notifyParticleExpired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyParticleMoved(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type *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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyParticleMoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__listT_Ogre__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_notifyParticleMoved", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_notifyParticleMoved", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  (arg1)->_notifyParticleMoved(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__notifyParticleCleared(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type *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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_notifyParticleCleared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__listT_Ogre__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_notifyParticleCleared", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_notifyParticleCleared", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  (arg1)->_notifyParticleCleared(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__createVisualData(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParticleVisualData *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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_createVisualData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  result = (Ogre::ParticleVisualData *)(arg1)->_createVisualData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleVisualData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__destroyVisualData(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::ParticleVisualData *arg2 = (Ogre::ParticleVisualData *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_destroyVisualData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleVisualData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleVisualData *","_destroyVisualData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleVisualData * >(argp2);
  (arg1)->_destroyVisualData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_setKeepParticlesInLocalSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","setKeepParticlesInLocalSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setKeepParticlesInLocalSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setKeepParticlesInLocalSpace(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer__getSortMode(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SortMode 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer const *","_getSortMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  result = (Ogre::SortMode)((Ogre::ParticleSystemRenderer const *)arg1)->_getSortMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemRenderer_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemRenderer *arg1 = (Ogre::ParticleSystemRenderer *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemRenderer_visitRenderables(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_Ogre__ParticleSystemRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleSystemRenderer_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleSystemRenderer_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystemRenderer.visitRenderables", 
    "    void ParticleSystemRenderer.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void ParticleSystemRenderer.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


swig_class SwigClassParticleSystemRendererFactory;

SWIGINTERN void
free_Ogre_ParticleSystemRendererFactory(Ogre::ParticleSystemRendererFactory *arg1) {
    delete arg1;
}

swig_class SwigClassBillboardSet;

SWIGINTERN VALUE
_wrap_new_BillboardSet__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  unsigned int arg2 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BillboardSet";
  Ogre::BillboardSet *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::BillboardSet", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardSet", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Ogre::BillboardSet", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::BillboardSet", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::BillboardSet *)new Ogre::BillboardSet((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_BillboardSet__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BillboardSet";
  Ogre::BillboardSet *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::BillboardSet", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardSet", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Ogre::BillboardSet", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Ogre::BillboardSet *)new Ogre::BillboardSet((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_BillboardSet__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::BillboardSet";
  Ogre::BillboardSet *result = 0 ;
  
  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 &","Ogre::BillboardSet", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BillboardSet", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::BillboardSet *)new Ogre::BillboardSet((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_BillboardSet(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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_BillboardSet__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _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_BillboardSet__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_BillboardSet__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "BillboardSet.new", 
    "    BillboardSet.new(Ogre::String const &name, unsigned int poolSize, bool externalDataSource)\n"
    "    BillboardSet.new(Ogre::String const &name, unsigned int poolSize)\n"
    "    BillboardSet.new(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_BillboardSet(Ogre::BillboardSet *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BillboardSet_createBillboard__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Billboard *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","createBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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 &","createBillboard", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createBillboard", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","createBillboard", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","createBillboard", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  result = (Ogre::Billboard *)(arg1)->createBillboard((Ogre::Vector3 const &)*arg2,(Ogre::ColourValue const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_createBillboard__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Billboard *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","createBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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 &","createBillboard", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createBillboard", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Billboard *)(arg1)->createBillboard((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_createBillboard__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::ColourValue *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Ogre::Billboard *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","createBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createBillboard", 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","createBillboard", 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","createBillboard", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","createBillboard", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","createBillboard", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::ColourValue * >(argp5);
  result = (Ogre::Billboard *)(arg1)->createBillboard(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_createBillboard__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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 ;
  Ogre::Billboard *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","createBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createBillboard", 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","createBillboard", 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","createBillboard", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::Billboard *)(arg1)->createBillboard(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_createBillboard(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_Ogre__BillboardSet, 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_BillboardSet_createBillboard__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 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__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_BillboardSet_createBillboard__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 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_BillboardSet_createBillboard__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_BillboardSet_createBillboard__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "BillboardSet.createBillboard", 
    "    Ogre::Billboard * BillboardSet.createBillboard(Ogre::Vector3 const &position, Ogre::ColourValue const &colour)\n"
    "    Ogre::Billboard * BillboardSet.createBillboard(Ogre::Vector3 const &position)\n"
    "    Ogre::Billboard * BillboardSet.createBillboard(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::ColourValue const &colour)\n"
    "    Ogre::Billboard * BillboardSet.createBillboard(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getNumBillboards(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getNumBillboards", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (int)((Ogre::BillboardSet const *)arg1)->getNumBillboards();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setAutoextend(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setAutoextend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoextend", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoextend(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getAutoextend(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getAutoextend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (bool)((Ogre::BillboardSet const *)arg1)->getAutoextend();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setSortingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setSortingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSortingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSortingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getSortingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getSortingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (bool)((Ogre::BillboardSet const *)arg1)->getSortingEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setPoolSize(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setPoolSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setPoolSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPoolSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getPoolSize(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getPoolSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (unsigned int)((Ogre::BillboardSet const *)arg1)->getPoolSize();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::BillboardSet.clear

  call-seq:
    clear

Clear BillboardSet contents.
*/
SWIGINTERN VALUE
_wrap_BillboardSet_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getBillboard(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Billboard *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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","getBillboard", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Ogre::Billboard *)((Ogre::BillboardSet const *)arg1)->getBillboard(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_removeBillboard__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","removeBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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","removeBillboard", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->removeBillboard(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_removeBillboard__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Billboard *arg2 = (Ogre::Billboard *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","removeBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Billboard, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Billboard *","removeBillboard", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Billboard * >(argp2);
  (arg1)->removeBillboard(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_removeBillboard(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_Ogre__BillboardSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Billboard, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BillboardSet_removeBillboard__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BillboardSet_removeBillboard__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "BillboardSet.removeBillboard", 
    "    void BillboardSet.removeBillboard(unsigned int index)\n"
    "    void BillboardSet.removeBillboard(Ogre::Billboard *pBill)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setBillboardOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::BillboardOrigin arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setBillboardOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BillboardOrigin","setBillboardOrigin", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BillboardOrigin >(val2);
  (arg1)->setBillboardOrigin(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getBillboardOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardOrigin 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getBillboardOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::BillboardOrigin)((Ogre::BillboardSet const *)arg1)->getBillboardOrigin();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setBillboardRotationType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::BillboardRotationType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setBillboardRotationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BillboardRotationType","setBillboardRotationType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BillboardRotationType >(val2);
  (arg1)->setBillboardRotationType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getBillboardRotationType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardRotationType 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getBillboardRotationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::BillboardRotationType)((Ogre::BillboardSet const *)arg1)->getBillboardRotationType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setDefaultDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setDefaultDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultDimensions", 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","setDefaultDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setDefaultDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setDefaultWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setDefaultWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDefaultWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getDefaultWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getDefaultWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setDefaultHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setDefaultHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDefaultHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getDefaultHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getDefaultHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setMaterialName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setMaterialName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_setMaterialName(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_Ogre__BillboardSet, 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_BillboardSet_setMaterialName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 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_BillboardSet_setMaterialName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardSet.setMaterialName", 
    "    void BillboardSet.setMaterialName(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void BillboardSet.setMaterialName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardSet const *)arg1)->getMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_beginBillboards__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","beginBillboards", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","beginBillboards", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->beginBillboards(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_beginBillboards__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","beginBillboards", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  (arg1)->beginBillboards();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_beginBillboards(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_Ogre__BillboardSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_BillboardSet_beginBillboards__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BillboardSet_beginBillboards__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "BillboardSet.beginBillboards", 
    "    void BillboardSet.beginBillboards(size_t numBillboards)\n"
    "    void BillboardSet.beginBillboards()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_injectBillboard(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Billboard *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","injectBillboard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Billboard,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Billboard const &","injectBillboard", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Billboard const &","injectBillboard", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Billboard * >(argp2);
  (arg1)->injectBillboard((Ogre::Billboard const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_endBillboards(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","endBillboards", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  (arg1)->endBillboards();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","setBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","setBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setBounds", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setBounds((Ogre::AxisAlignedBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::BillboardSet const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::BillboardSet const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::MaterialPtr *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::RenderOperation *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::BillboardSet const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet__notifyBillboardResized(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","_notifyBillboardResized", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  (arg1)->_notifyBillboardResized();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet__notifyBillboardRotated(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","_notifyBillboardRotated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  (arg1)->_notifyBillboardRotated();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getCullIndividually(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getCullIndividually", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (bool)((Ogre::BillboardSet const *)arg1)->getCullIndividually();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setCullIndividually(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setCullIndividually", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCullIndividually", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCullIndividually(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setBillboardType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::BillboardType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setBillboardType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BillboardType","setBillboardType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BillboardType >(val2);
  (arg1)->setBillboardType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getBillboardType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardType 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getBillboardType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::BillboardType)((Ogre::BillboardSet const *)arg1)->getBillboardType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setCommonDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Vector3 *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setCommonDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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 &","setCommonDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setCommonDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setCommonDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getCommonDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getCommonDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::BillboardSet const *)arg1)->getCommonDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setCommonUpVector(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Vector3 *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setCommonUpVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(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 &","setCommonUpVector", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setCommonUpVector", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setCommonUpVector((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getCommonUpVector(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getCommonUpVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::BillboardSet const *)arg1)->getCommonUpVector();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setUseAccurateFacing(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setUseAccurateFacing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseAccurateFacing", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseAccurateFacing(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getUseAccurateFacing(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getUseAccurateFacing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (bool)((Ogre::BillboardSet const *)arg1)->getUseAccurateFacing();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardSet const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::BillboardSet const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet__updateBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","_updateBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  (arg1)->_updateBounds();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::LightList *) &((Ogre::BillboardSet const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardSet_visitRenderables(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_Ogre__BillboardSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BillboardSet_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BillboardSet_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardSet.visitRenderables", 
    "    void BillboardSet.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BillboardSet.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet__sortBillboards(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","_sortBillboards", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_sortBillboards", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_sortBillboards(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet__getSortMode(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SortMode 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","_getSortMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::SortMode)((Ogre::BillboardSet const *)arg1)->_getSortMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setBillboardsInWorldSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setBillboardsInWorldSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBillboardsInWorldSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBillboardsInWorldSpace(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setTextureCoords(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::FloatRect *arg2 = (Ogre::FloatRect *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setTextureCoords", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FloatRect const *","setTextureCoords", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::FloatRect * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","setTextureCoords", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  (arg1)->setTextureCoords((Ogre::FloatRect const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setTextureStacksAndSlices(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::uchar arg2 ;
  Ogre::uchar arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setTextureStacksAndSlices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uchar","setTextureStacksAndSlices", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uchar >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uchar","setTextureStacksAndSlices", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uchar >(val3);
  (arg1)->setTextureStacksAndSlices(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getTextureCoords(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  Ogre::uint16 *arg2 = (Ogre::uint16 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::FloatRect *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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","getTextureCoords", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uint16 *","getTextureCoords", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::uint16 * >(argp2);
  result = (Ogre::FloatRect *)(arg1)->getTextureCoords(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setPointRenderingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setPointRenderingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPointRenderingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPointRenderingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_isPointRenderingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","isPointRenderingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (bool)((Ogre::BillboardSet const *)arg1)->isPointRenderingEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (Ogre::uint32)((Ogre::BillboardSet const *)arg1)->getTypeFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_setAutoUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","setAutoUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_getAutoUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet const *","getAutoUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  result = (bool)((Ogre::BillboardSet const *)arg1)->getAutoUpdate();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSet_notifyBillboardDataChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSet *arg1 = (Ogre::BillboardSet *) 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_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","notifyBillboardDataChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSet * >(argp1);
  (arg1)->notifyBillboardDataChanged();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassBillboardSetFactory;

SWIGINTERN void
free_Ogre_BillboardSetFactory(Ogre::BillboardSetFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BillboardSetFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::BillboardSetFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_BillboardSetFactory_FACTORY_TYPE_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::BillboardSetFactory::FACTORY_TYPE_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::BillboardSetFactory::FACTORY_TYPE_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSetFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSetFactory *arg1 = (Ogre::BillboardSetFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardSetFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSetFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSetFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardSetFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardSetFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardSetFactory *arg1 = (Ogre::BillboardSetFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__BillboardSetFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardSetFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardSetFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassBillboardParticleRenderer;

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

SWIGINTERN VALUE
_wrap_new_BillboardParticleRenderer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::BillboardParticleRenderer";
  Ogre::BillboardParticleRenderer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::BillboardParticleRenderer *)new Ogre::BillboardParticleRenderer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BillboardParticleRenderer(Ogre::BillboardParticleRenderer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setBillboardType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::BillboardType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setBillboardType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BillboardType","setBillboardType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BillboardType >(val2);
  (arg1)->setBillboardType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getBillboardType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardType 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getBillboardType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::BillboardType)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setUseAccurateFacing(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setUseAccurateFacing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseAccurateFacing", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseAccurateFacing(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getUseAccurateFacing(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getUseAccurateFacing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (bool)((Ogre::BillboardParticleRenderer const *)arg1)->getUseAccurateFacing();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setBillboardOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::BillboardOrigin arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setBillboardOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BillboardOrigin","setBillboardOrigin", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BillboardOrigin >(val2);
  (arg1)->setBillboardOrigin(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getBillboardOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardOrigin 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getBillboardOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::BillboardOrigin)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardOrigin();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setBillboardRotationType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::BillboardRotationType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setBillboardRotationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BillboardRotationType","setBillboardRotationType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BillboardRotationType >(val2);
  (arg1)->setBillboardRotationType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getBillboardRotationType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardRotationType 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getBillboardRotationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::BillboardRotationType)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardRotationType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setCommonDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Vector3 *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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setCommonDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(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 &","setCommonDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setCommonDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setCommonDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getCommonDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getCommonDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::BillboardParticleRenderer const *)arg1)->getCommonDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setCommonUpVector(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Vector3 *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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setCommonUpVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(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 &","setCommonUpVector", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setCommonUpVector", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setCommonUpVector((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getCommonUpVector(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getCommonUpVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::BillboardParticleRenderer const *)arg1)->getCommonUpVector();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setPointRenderingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setPointRenderingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPointRenderingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPointRenderingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_isPointRenderingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","isPointRenderingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (bool)((Ogre::BillboardParticleRenderer const *)arg1)->isPointRenderingEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardParticleRenderer const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 0 ;
  Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__listT_Ogre__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_updateRenderQueue", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type &","_updateRenderQueue", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_updateRenderQueue", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_updateRenderQueue(arg2,*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardParticleRenderer_visitRenderables(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_Ogre__BillboardParticleRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BillboardParticleRenderer_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardParticleRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BillboardParticleRenderer_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardParticleRenderer.visitRenderables", 
    "    void BillboardParticleRenderer.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BillboardParticleRenderer.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::MaterialPtr *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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr &","_setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr &","_setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->_setMaterial(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notifyParticleRotated(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_notifyParticleRotated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  (arg1)->_notifyParticleRotated();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notifyParticleResized(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_notifyParticleResized", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  (arg1)->_notifyParticleResized();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notifyParticleQuota(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_notifyParticleQuota", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_notifyParticleQuota", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->_notifyParticleQuota(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notifyAttached__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAttached", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAttached(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notifyAttached__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BillboardParticleRenderer__notifyAttached(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_Ogre__BillboardParticleRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BillboardParticleRenderer__notifyAttached__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BillboardParticleRenderer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BillboardParticleRenderer__notifyAttached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BillboardParticleRenderer._notifyAttached", 
    "    void BillboardParticleRenderer._notifyAttached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void BillboardParticleRenderer._notifyAttached(Ogre::Node *parent)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__notifyDefaultDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","_notifyDefaultDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_notifyDefaultDimensions", 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","_notifyDefaultDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->_notifyDefaultDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_setKeepParticlesInLocalSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer *","setKeepParticlesInLocalSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setKeepParticlesInLocalSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setKeepParticlesInLocalSpace(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer__getSortMode(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SortMode 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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","_getSortMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::SortMode)((Ogre::BillboardParticleRenderer const *)arg1)->_getSortMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRenderer_getBillboardSet(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRenderer *arg1 = (Ogre::BillboardParticleRenderer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardSet *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_Ogre__BillboardParticleRenderer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRenderer const *","getBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRenderer * >(argp1);
  result = (Ogre::BillboardSet *)((Ogre::BillboardParticleRenderer const *)arg1)->getBillboardSet();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassBillboardParticleRendererFactory;

SWIGINTERN VALUE
_wrap_BillboardParticleRendererFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRendererFactory *arg1 = (Ogre::BillboardParticleRendererFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BillboardParticleRendererFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRendererFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRendererFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::BillboardParticleRendererFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRendererFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRendererFactory *arg1 = (Ogre::BillboardParticleRendererFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ParticleSystemRenderer *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_Ogre__BillboardParticleRendererFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRendererFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRendererFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleSystemRenderer *)(arg1)->createInstance((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BillboardParticleRendererFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::BillboardParticleRendererFactory *arg1 = (Ogre::BillboardParticleRendererFactory *) 0 ;
  Ogre::ParticleSystemRenderer *arg2 = (Ogre::ParticleSystemRenderer *) 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_Ogre__BillboardParticleRendererFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BillboardParticleRendererFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BillboardParticleRendererFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_BillboardParticleRendererFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::BillboardParticleRendererFactory";
  Ogre::BillboardParticleRendererFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::BillboardParticleRendererFactory *)new Ogre::BillboardParticleRendererFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BillboardParticleRendererFactory(Ogre::BillboardParticleRendererFactory *arg1) {
    delete arg1;
}

swig_class SwigClassBitwise;

SWIGINTERN VALUE
_wrap_Bitwise_mostSignificantBitSet(int argc, VALUE *argv, VALUE self) {
  unsigned int arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Ogre::Bitwise::mostSignificantBitSet", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned int >(val1);
  result = (unsigned int)Ogre::Bitwise::mostSignificantBitSet(arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_firstPO2From(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Ogre::uint32 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::Bitwise::firstPO2From", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint32 >(val1);
  result = (Ogre::uint32)Ogre::Bitwise::firstPO2From(arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_fixedToFixed(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 arg1 ;
  unsigned int arg2 ;
  unsigned int arg3 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned 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_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::Bitwise::fixedToFixed", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint32 >(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","Ogre::Bitwise::fixedToFixed", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(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","Ogre::Bitwise::fixedToFixed", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (unsigned int)Ogre::Bitwise::fixedToFixed(arg1,arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_floatToFixed(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  unsigned int arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "float","Ogre::Bitwise::floatToFixed", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(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","Ogre::Bitwise::floatToFixed", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (unsigned int)Ogre::Bitwise::floatToFixed(arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_fixedToFloat(int argc, VALUE *argv, VALUE self) {
  unsigned int arg1 ;
  unsigned int arg2 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float 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_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned int","Ogre::Bitwise::fixedToFloat", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned int >(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","Ogre::Bitwise::fixedToFloat", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (float)Ogre::Bitwise::fixedToFloat(arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_intWrite(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int arg2 ;
  unsigned int arg3 ;
  int res1 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::Bitwise::intWrite", 1, argv[0] )); 
  }
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Ogre::Bitwise::intWrite", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(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","Ogre::Bitwise::intWrite", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  Ogre::Bitwise::intWrite(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_intRead(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int arg2 ;
  int res1 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int 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],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void const *","Ogre::Bitwise::intRead", 1, argv[0] )); 
  }
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Ogre::Bitwise::intRead", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (unsigned int)Ogre::Bitwise::intRead((void const *)arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_floatToHalf(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  Ogre::uint16 result;
  VALUE vresult = Qnil;
  
  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( "", "float","Ogre::Bitwise::floatToHalf", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  result = (Ogre::uint16)Ogre::Bitwise::floatToHalf(arg1);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_floatToHalfI(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Ogre::uint16 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::Bitwise::floatToHalfI", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint32 >(val1);
  result = (Ogre::uint16)Ogre::Bitwise::floatToHalfI(arg1);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_halfToFloat(int argc, VALUE *argv, VALUE self) {
  Ogre::uint16 arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  float result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Bitwise::halfToFloat", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint16 >(val1);
  result = (float)Ogre::Bitwise::halfToFloat(arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bitwise_halfToFloatI(int argc, VALUE *argv, VALUE self) {
  Ogre::uint16 arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  Ogre::uint32 result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Bitwise::halfToFloatI", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint16 >(val1);
  result = (Ogre::uint32)Ogre::Bitwise::halfToFloatI(arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Bitwise(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Bitwise";
  Ogre::Bitwise *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Bitwise *)new Ogre::Bitwise();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Bitwise(Ogre::Bitwise *arg1) {
    delete arg1;
}

swig_class SwigClassSkeleton;

SWIGINTERN VALUE
_wrap_new_Skeleton__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Skeleton";
  Ogre::Skeleton *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Skeleton", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Skeleton", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Skeleton", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Skeleton", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Skeleton", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Skeleton", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Skeleton", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","Ogre::Skeleton", 6, argv[5] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::Skeleton *)new Ogre::Skeleton(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Skeleton__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Skeleton";
  Ogre::Skeleton *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Skeleton", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Skeleton", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Skeleton", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Skeleton", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Skeleton", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Skeleton", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Skeleton", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::Skeleton *)new Ogre::Skeleton(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Skeleton__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Skeleton";
  Ogre::Skeleton *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Skeleton", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Skeleton", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Skeleton", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Skeleton", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Skeleton", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Skeleton", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::Skeleton *)new Ogre::Skeleton(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Skeleton(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Skeleton__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Skeleton__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Skeleton__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Skeleton.new", 
    "    Skeleton.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Skeleton.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual)\n"
    "    Skeleton.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Skeleton(Ogre::Skeleton *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Skeleton_createBone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Bone *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","createBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (Ogre::Bone *)(arg1)->createBone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_createBone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Bone *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","createBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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","createBone", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Bone *)(arg1)->createBone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_createBone__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Bone *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","createBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","createBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Bone *)(arg1)->createBone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_createBone__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::Bone *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","createBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","createBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","createBone", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = (Ogre::Bone *)(arg1)->createBone((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_createBone(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_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Skeleton_createBone__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Skeleton_createBone__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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_Skeleton_createBone__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Skeleton_createBone__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton.createBone", 
    "    Ogre::Bone * Skeleton.createBone()\n"
    "    Ogre::Bone * Skeleton.createBone(unsigned short handle)\n"
    "    Ogre::Bone * Skeleton.createBone(Ogre::String const &name)\n"
    "    Ogre::Bone * Skeleton.createBone(Ogre::String const &name, unsigned short handle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getNumBones(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getNumBones", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (unsigned short)((Ogre::Skeleton const *)arg1)->getNumBones();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getRootBone(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Bone *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getRootBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (Ogre::Bone *)((Ogre::Skeleton const *)arg1)->getRootBone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getRootBoneIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::Bone *,Ogre::STLAllocator< Ogre::Bone *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","getRootBoneIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (arg1)->getRootBoneIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Skeleton::BoneIterator(static_cast< const Ogre::Skeleton::BoneIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getBoneIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::Bone *,Ogre::STLAllocator< Ogre::Bone *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","getBoneIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (arg1)->getBoneIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Skeleton::BoneIterator(static_cast< const Ogre::Skeleton::BoneIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getBone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Bone *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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","getBone", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Bone *)((Ogre::Skeleton const *)arg1)->getBone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getBone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Bone *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","getBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Bone *)((Ogre::Skeleton const *)arg1)->getBone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_getBone(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_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Skeleton_getBone__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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_Skeleton_getBone__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Skeleton.getBone", 
    "    Ogre::Bone * Skeleton.getBone(unsigned short handle)\n"
    "    Ogre::Bone * Skeleton.getBone(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_hasBone(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","hasBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","hasBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::Skeleton const *)arg1)->hasBone((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_setBindingPose(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","setBindingPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  (arg1)->setBindingPose();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_reset__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","reset", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->reset(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_reset__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_reset(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_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Skeleton_reset__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Skeleton_reset__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Skeleton.reset", 
    "    void Skeleton.reset(bool resetManualBones)\n"
    "    void Skeleton.reset()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_createAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Animation *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","createAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","createAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getAnimation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LinkedSkeletonAnimationSource **arg3 = (Ogre::LinkedSkeletonAnimationSource **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Animation *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource const **","getAnimation", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource ** >(argp3);
  result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->getAnimation((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getAnimation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->getAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__getAnimationImpl__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LinkedSkeletonAnimationSource **arg3 = (Ogre::LinkedSkeletonAnimationSource **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Animation *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_getAnimationImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","_getAnimationImpl", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getAnimationImpl", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource const **","_getAnimationImpl", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource ** >(argp3);
  result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__getAnimationImpl__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_getAnimationImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","_getAnimationImpl", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getAnimationImpl", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton__getAnimationImpl(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_Ogre__Skeleton, 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_Skeleton__getAnimationImpl__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Skeleton__getAnimationImpl__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton._getAnimationImpl", 
    "    Ogre::Animation * Skeleton._getAnimationImpl(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * Skeleton._getAnimationImpl(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_hasAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","hasAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","hasAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::Skeleton const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_removeAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","removeAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","removeAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeAnimation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_setAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::AnimationStateSet *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","setAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AnimationStateSet,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet const &","setAnimationState", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AnimationStateSet const &","setAnimationState", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (arg1)->setAnimationState((Ogre::AnimationStateSet const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__initAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_initAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_initAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (arg1)->_initAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__refreshAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_refreshAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_refreshAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (arg1)->_refreshAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__getBoneMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_getBoneMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","_getBoneMatrices", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->_getBoneMatrices(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getNumAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getNumAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (unsigned short)((Ogre::Skeleton const *)arg1)->getNumAnimations();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getAnimation__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Animation *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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","getAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Animation *)((Ogre::Skeleton const *)arg1)->getAnimation(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_getAnimation(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_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Skeleton_getAnimation__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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_Skeleton_getAnimation__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Skeleton_getAnimation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton.getAnimation", 
    "    Ogre::Animation * Skeleton.getAnimation(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * Skeleton.getAnimation(Ogre::String const &name)\n"
    "    Ogre::Animation * Skeleton.getAnimation(unsigned short index)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getBlendMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonAnimationBlendMode 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getBlendMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (Ogre::SkeletonAnimationBlendMode)((Ogre::Skeleton const *)arg1)->getBlendMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_setBlendMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::SkeletonAnimationBlendMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","setBlendMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SkeletonAnimationBlendMode","setBlendMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SkeletonAnimationBlendMode >(val2);
  (arg1)->setBlendMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__updateTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_updateTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  (arg1)->_updateTransforms();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_optimiseAllAnimations__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","optimiseAllAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","optimiseAllAnimations", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->optimiseAllAnimations(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_optimiseAllAnimations__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","optimiseAllAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  (arg1)->optimiseAllAnimations();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_optimiseAllAnimations(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_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Skeleton_optimiseAllAnimations__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Skeleton_optimiseAllAnimations__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Skeleton.optimiseAllAnimations", 
    "    void Skeleton.optimiseAllAnimations(bool preservingIdentityNodeTracks)\n"
    "    void Skeleton.optimiseAllAnimations()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_addLinkedSkeletonAnimationSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","addLinkedSkeletonAnimationSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addLinkedSkeletonAnimationSource", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_addLinkedSkeletonAnimationSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","addLinkedSkeletonAnimationSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(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( "", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton_addLinkedSkeletonAnimationSource(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_Ogre__Skeleton, 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_Skeleton_addLinkedSkeletonAnimationSource__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Skeleton_addLinkedSkeletonAnimationSource__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Skeleton.addLinkedSkeletonAnimationSource", 
    "    void Skeleton.addLinkedSkeletonAnimationSource(Ogre::String const &skelName, Ogre::Real scale)\n"
    "    void Skeleton.addLinkedSkeletonAnimationSource(Ogre::String const &skelName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_removeAllLinkedSkeletonAnimationSources(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","removeAllLinkedSkeletonAnimationSources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  (arg1)->removeAllLinkedSkeletonAnimationSources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getLinkedSkeletonAnimationSourceIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::LinkedSkeletonAnimationSource,Ogre::STLAllocator< Ogre::LinkedSkeletonAnimationSource,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getLinkedSkeletonAnimationSourceIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = ((Ogre::Skeleton const *)arg1)->getLinkedSkeletonAnimationSourceIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Skeleton::LinkedSkeletonAnimSourceIterator(static_cast< const Ogre::Skeleton::LinkedSkeletonAnimSourceIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__notifyManualBonesDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_notifyManualBonesDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  (arg1)->_notifyManualBonesDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__notifyManualBoneStateChange(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::Bone *arg2 = (Ogre::Bone *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_notifyManualBoneStateChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Bone *","_notifyManualBoneStateChange", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Bone * >(argp2);
  (arg1)->_notifyManualBoneStateChange(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_getManualBonesDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","getManualBonesDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (bool)((Ogre::Skeleton const *)arg1)->getManualBonesDirty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton_hasManualBones(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","hasManualBones", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (bool)((Ogre::Skeleton const *)arg1)->hasManualBones();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__mergeSkeletonAnimations__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton::BoneHandleMap *arg3 = 0 ;
  Ogre::StringVector *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_mergeSkeletonAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_mergeSkeletonAnimations", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Skeleton::BoneHandleMap const &","_mergeSkeletonAnimations", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Skeleton::BoneHandleMap const &","_mergeSkeletonAnimations", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Skeleton::BoneHandleMap * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::StringVector const &","_mergeSkeletonAnimations", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StringVector const &","_mergeSkeletonAnimations", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::StringVector * >(argp4);
  (arg1)->_mergeSkeletonAnimations((Ogre::Skeleton const *)arg2,(Ogre::Skeleton::BoneHandleMap const &)*arg3,(Ogre::StringVector const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__mergeSkeletonAnimations__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton::BoneHandleMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","_mergeSkeletonAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_mergeSkeletonAnimations", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Skeleton::BoneHandleMap const &","_mergeSkeletonAnimations", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Skeleton::BoneHandleMap const &","_mergeSkeletonAnimations", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Skeleton::BoneHandleMap * >(argp3);
  (arg1)->_mergeSkeletonAnimations((Ogre::Skeleton const *)arg2,(Ogre::Skeleton::BoneHandleMap const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Skeleton__mergeSkeletonAnimations(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_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Skeleton__mergeSkeletonAnimations__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Skeleton__mergeSkeletonAnimations__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Skeleton._mergeSkeletonAnimations", 
    "    void Skeleton._mergeSkeletonAnimations(Ogre::Skeleton const *source, Ogre::Skeleton::BoneHandleMap const &boneHandleMap, Ogre::StringVector const &animations)\n"
    "    void Skeleton._mergeSkeletonAnimations(Ogre::Skeleton const *source, Ogre::Skeleton::BoneHandleMap const &boneHandleMap)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__buildMapBoneByHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton::BoneHandleMap *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_buildMapBoneByHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_buildMapBoneByHandle", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Skeleton::BoneHandleMap &","_buildMapBoneByHandle", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Skeleton::BoneHandleMap &","_buildMapBoneByHandle", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Skeleton::BoneHandleMap * >(argp3);
  ((Ogre::Skeleton const *)arg1)->_buildMapBoneByHandle((Ogre::Skeleton const *)arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Skeleton__buildMapBoneByName(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::Skeleton::BoneHandleMap *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_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_buildMapBoneByName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","_buildMapBoneByName", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Skeleton::BoneHandleMap &","_buildMapBoneByName", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Skeleton::BoneHandleMap &","_buildMapBoneByName", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Skeleton::BoneHandleMap * >(argp3);
  ((Ogre::Skeleton const *)arg1)->_buildMapBoneByName((Ogre::Skeleton const *)arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassSkeletonPtr;

SWIGINTERN VALUE
_wrap_new_SkeletonPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SkeletonPtr";
  Ogre::SkeletonPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SkeletonPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Skeleton *arg1 = (Ogre::Skeleton *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::SkeletonPtr";
  Ogre::SkeletonPtr *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__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Skeleton *","Ogre::SkeletonPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Skeleton * >(argp1);
  result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_SkeletonPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::SkeletonPtr";
  Ogre::SkeletonPtr *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__SkeletonPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonPtr const &","Ogre::SkeletonPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SkeletonPtr const &","Ogre::SkeletonPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonPtr * >(argp1);
  result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr((Ogre::SkeletonPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_SkeletonPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::SkeletonPtr";
  Ogre::SkeletonPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::SkeletonPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::SkeletonPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::SkeletonPtr *)new Ogre::SkeletonPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SkeletonPtr(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_SkeletonPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SkeletonPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SkeletonPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SkeletonPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "SkeletonPtr.new", 
    "    SkeletonPtr.new()\n"
    "    SkeletonPtr.new(Ogre::Skeleton *rep)\n"
    "    SkeletonPtr.new(Ogre::SkeletonPtr const &r)\n"
    "    SkeletonPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_SkeletonPtr(Ogre::SkeletonPtr *arg1) {
    delete arg1;
}

swig_class SwigClassLinkedSkeletonAnimationSource;

SWIGINTERN VALUE
_wrap_LinkedSkeletonAnimationSource_skeletonName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LinkedSkeletonAnimationSource *arg1 = (Ogre::LinkedSkeletonAnimationSource *) 0 ;
  Ogre::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_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource *","skeletonName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource * >(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( "", "Ogre::String const &","skeletonName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","skeletonName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->skeletonName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinkedSkeletonAnimationSource_skeletonName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LinkedSkeletonAnimationSource *arg1 = (Ogre::LinkedSkeletonAnimationSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource *","skeletonName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource * >(argp1);
  result = (Ogre::String *) & ((arg1)->skeletonName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinkedSkeletonAnimationSource_pSkeleton_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LinkedSkeletonAnimationSource *arg1 = (Ogre::LinkedSkeletonAnimationSource *) 0 ;
  Ogre::SkeletonPtr *arg2 = (Ogre::SkeletonPtr *) 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_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource *","pSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SkeletonPtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SkeletonPtr *","pSkeleton", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SkeletonPtr * >(argp2);
  if (arg1) (arg1)->pSkeleton = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinkedSkeletonAnimationSource_pSkeleton_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LinkedSkeletonAnimationSource *arg1 = (Ogre::LinkedSkeletonAnimationSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonPtr *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_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource *","pSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource * >(argp1);
  result = (Ogre::SkeletonPtr *)& ((arg1)->pSkeleton);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinkedSkeletonAnimationSource_scale_set(int argc, VALUE *argv, VALUE self) {
  Ogre::LinkedSkeletonAnimationSource *arg1 = (Ogre::LinkedSkeletonAnimationSource *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource * >(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);
  if (arg1) (arg1)->scale = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LinkedSkeletonAnimationSource_scale_get(int argc, VALUE *argv, VALUE self) {
  Ogre::LinkedSkeletonAnimationSource *arg1 = (Ogre::LinkedSkeletonAnimationSource *) 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_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource * >(argp1);
  result = (Ogre::Real) ((arg1)->scale);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_LinkedSkeletonAnimationSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Real arg2 ;
  int res1 = SWIG_OLDOBJ ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::LinkedSkeletonAnimationSource";
  Ogre::LinkedSkeletonAnimationSource *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::LinkedSkeletonAnimationSource", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::LinkedSkeletonAnimationSource", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::LinkedSkeletonAnimationSource", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::LinkedSkeletonAnimationSource *)new Ogre::LinkedSkeletonAnimationSource((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_LinkedSkeletonAnimationSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Real arg2 ;
  Ogre::SkeletonPtr arg3 ;
  int res1 = SWIG_OLDOBJ ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::LinkedSkeletonAnimationSource";
  Ogre::LinkedSkeletonAnimationSource *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::LinkedSkeletonAnimationSource", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::LinkedSkeletonAnimationSource", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::LinkedSkeletonAnimationSource", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__SkeletonPtr,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SkeletonPtr","Ogre::LinkedSkeletonAnimationSource", 3, argv[2] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SkeletonPtr","Ogre::LinkedSkeletonAnimationSource", 3, argv[2]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::SkeletonPtr * >(argp3));
    }
  }
  result = (Ogre::LinkedSkeletonAnimationSource *)new Ogre::LinkedSkeletonAnimationSource((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_LinkedSkeletonAnimationSource(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 == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_LinkedSkeletonAnimationSource__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SkeletonPtr, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_LinkedSkeletonAnimationSource__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "LinkedSkeletonAnimationSource.new", 
    "    LinkedSkeletonAnimationSource.new(Ogre::String const &skelName, Ogre::Real scl)\n"
    "    LinkedSkeletonAnimationSource.new(Ogre::String const &skelName, Ogre::Real scl, Ogre::SkeletonPtr skelPtr)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_LinkedSkeletonAnimationSource(Ogre::LinkedSkeletonAnimationSource *arg1) {
    delete arg1;
}

swig_class SwigClassMeshSharedPtr;

SWIGINTERN VALUE
_wrap_new_MeshSharedPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MeshSharedPtr";
  Ogre::SharedPtr< Ogre::Mesh > *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SharedPtr< Ogre::Mesh > *)new Ogre::SharedPtr< Ogre::Mesh >();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MeshSharedPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MeshSharedPtr";
  Ogre::SharedPtr< Ogre::Mesh > *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__SharedPtrT_Ogre__Mesh_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const &","Ogre::SharedPtr<(Ogre::Mesh)>", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SharedPtr< Ogre::Mesh > const &","Ogre::SharedPtr<(Ogre::Mesh)>", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::SharedPtr< Ogre::Mesh > *)new Ogre::SharedPtr< Ogre::Mesh >((Ogre::SharedPtr< Ogre::Mesh > const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MeshSharedPtr(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_MeshSharedPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MeshSharedPtr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MeshSharedPtr.new", 
    "    MeshSharedPtr.new()\n"
    "    MeshSharedPtr.new(Ogre::SharedPtr< Ogre::Mesh > const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_SharedPtr_Sl_Ogre_Mesh_Sg_(Ogre::SharedPtr< Ogre::Mesh > *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MeshSharedPtr___ref__(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Mesh *) &((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->operator *();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr___deref__(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","operator ->", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Mesh *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->operator ->();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Mesh *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->get();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_bind__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  Ogre::SharedPtrFreeMethod arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","bind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh *","bind", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SharedPtrFreeMethod","bind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SharedPtrFreeMethod >(val3);
  (arg1)->bind(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_bind__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","bind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh *","bind", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  (arg1)->bind(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_bind(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MeshSharedPtr_bind__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MeshSharedPtr_bind__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MeshSharedPtr.bind", 
    "    void MeshSharedPtr.bind(Ogre::Mesh *rep, Ogre::SharedPtrFreeMethod inFreeMethod)\n"
    "    void MeshSharedPtr.bind(Ogre::Mesh *rep)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_unique(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","unique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->unique();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_useCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","useCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (unsigned int)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->useCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_useCountPointer(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","useCountPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (unsigned int *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->useCountPointer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getPointer(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Mesh *)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->getPointer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_freeMethod(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SharedPtrFreeMethod 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","freeMethod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::SharedPtrFreeMethod)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->freeMethod();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isNull(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)((Ogre::SharedPtr< Ogre::Mesh > const *)arg1)->isNull();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setNull(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setNull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (arg1)->setNull();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_createSubMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SubMesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","createSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::SubMesh *)(*arg1)->createSubMesh();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_createSubMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SubMesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","createSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","createSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SubMesh *)(*arg1)->createSubMesh((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_createSubMesh(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_createSubMesh__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_createSubMesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.createSubMesh", 
    "    Ogre::SubMesh * Mesh.createSubMesh()\n"
    "    Ogre::SubMesh * Mesh.createSubMesh(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_nameSubMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","nameSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","nameSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","nameSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","nameSubMesh", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (*arg1)->nameSubMesh((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_unnameSubMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","unnameSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","unnameSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unnameSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->unnameSubMesh((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__getSubMeshIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ushort 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","_getSubMeshIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","_getSubMeshIndex", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getSubMeshIndex", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ushort)(*arg1)->_getSubMeshIndex((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getNumSubMeshes(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getNumSubMeshes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (unsigned short)(*arg1)->getNumSubMeshes();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSubMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::SubMesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","getSubMesh", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::SubMesh *)(*arg1)->getSubMesh(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSubMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SubMesh *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","getSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SubMesh *)(*arg1)->getSubMesh((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_getSubMesh(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_getSubMesh__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_getSubMesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getSubMesh", 
    "    Ogre::SubMesh * Mesh.getSubMesh(unsigned short index)\n"
    "    Ogre::SubMesh * Mesh.getSubMesh(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_destroySubMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","destroySubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","destroySubMesh", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (*arg1)->destroySubMesh(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_destroySubMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","destroySubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","destroySubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroySubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->destroySubMesh((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_destroySubMesh(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_destroySubMesh__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_destroySubMesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.destroySubMesh", 
    "    void Mesh.destroySubMesh(unsigned short index)\n"
    "    void Mesh.destroySubMesh(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSubMeshIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::SubMesh *,Ogre::STLAllocator< Ogre::SubMesh *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getSubMeshIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (*arg1)->getSubMeshIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Mesh::SubMeshIterator(static_cast< const Ogre::Mesh::SubMeshIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_sharedVertexData_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","sharedVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","sharedVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  if (arg1) (*arg1)->sharedVertexData = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_sharedVertexData_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","sharedVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::VertexData *) ((*arg1)->sharedVertexData);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_sharedBlendIndexToBoneIndexMap_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Mesh::IndexMap *arg2 = (Ogre::Mesh::IndexMap *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","sharedBlendIndexToBoneIndexMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap *","sharedBlendIndexToBoneIndexMap", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp2);
  if (arg1) (*arg1)->sharedBlendIndexToBoneIndexMap = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_sharedBlendIndexToBoneIndexMap_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh::IndexMap *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","sharedBlendIndexToBoneIndexMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Mesh::IndexMap *)& ((*arg1)->sharedBlendIndexToBoneIndexMap);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Mesh.clone

  call-seq:
    clone(newName, newGroup=BLANK) -> MeshPtr
    clone(newName) -> MeshPtr

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_MeshSharedPtr_clone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 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 &","clone", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (*arg1)->clone((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  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_MeshSharedPtr_clone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (*arg1)->clone((Ogre::String const &)*arg2);
  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_MeshSharedPtr_clone(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_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_clone__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_clone__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.clone", 
    "    Ogre::MeshPtr Mesh.clone(Ogre::String const &newName, Ogre::String const &newGroup)\n"
    "    Ogre::MeshPtr Mesh.clone(Ogre::String const &newName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::AxisAlignedBox *) &(*arg1)->getBounds();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getBoundingSphereRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getBoundingSphereRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Real)(*arg1)->getBoundingSphereRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__setBounds__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_setBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setBounds", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (*arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__setBounds__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_setBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (*arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr__setBounds(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MeshSharedPtr__setBounds__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MeshSharedPtr__setBounds__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh._setBounds", 
    "    void Mesh._setBounds(Ogre::AxisAlignedBox const &bounds, bool pad)\n"
    "    void Mesh._setBounds(Ogre::AxisAlignedBox const &bounds)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__setBoundingSphereRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_setBoundingSphereRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_setBoundingSphereRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (*arg1)->_setBoundingSphereRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setSkeletonName(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setSkeletonName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","setSkeletonName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkeletonName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->setSkeletonName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_hasSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","hasSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->hasSkeleton();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_hasVertexAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","hasVertexAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->hasVertexAnimation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonPtr *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::SkeletonPtr *) &(*arg1)->getSkeleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSkeletonName(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSkeletonName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getSkeletonName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__initAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_initAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_initAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (*arg1)->_initAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__refreshAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_refreshAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_refreshAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (*arg1)->_refreshAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_addBoneAssignment(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexBoneAssignment *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","addBoneAssignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__VertexBoneAssignment_s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment const &","addBoneAssignment", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexBoneAssignment const &","addBoneAssignment", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBoneAssignment * >(argp2);
  (*arg1)->addBoneAssignment((Ogre::VertexBoneAssignment const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_clearBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","clearBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->clearBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__notifySkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::SkeletonPtr *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_notifySkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SkeletonPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SkeletonPtr &","_notifySkeleton", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SkeletonPtr &","_notifySkeleton", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::SkeletonPtr * >(argp2);
  (*arg1)->_notifySkeleton(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getBoneAssignmentIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::multimap< size_t,Ogre::VertexBoneAssignment,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::VertexBoneAssignment >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getBoneAssignmentIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (*arg1)->getBoneAssignmentIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Mesh::BoneAssignmentIterator(static_cast< const Ogre::Mesh::BoneAssignmentIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh::VertexBoneAssignmentList *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Mesh::VertexBoneAssignmentList *) &(*arg1)->getBoneAssignments();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getNumLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getNumLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::ushort)(*arg1)->getNumLodLevels();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getLodLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::MeshLodUsage *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","getLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::MeshLodUsage *) &(*arg1)->getLodLevel(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshLodUsage, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_createManualLodLevel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","createManualLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createManualLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    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 &","createManualLodLevel", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManualLodLevel", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createManualLodLevel", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManualLodLevel", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (*arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_createManualLodLevel__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","createManualLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createManualLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    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 &","createManualLodLevel", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManualLodLevel", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (*arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_createManualLodLevel(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_Ogre__SharedPtrT_Ogre__Mesh_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MeshSharedPtr_createManualLodLevel__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MeshSharedPtr_createManualLodLevel__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Mesh.createManualLodLevel", 
    "    void Mesh.createManualLodLevel(Ogre::Real value, Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    void Mesh.createManualLodLevel(Ogre::Real value, Ogre::String const &meshName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_updateManualLodLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","updateManualLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","updateManualLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  {
    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 &","updateManualLodLevel", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","updateManualLodLevel", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (*arg1)->updateManualLodLevel(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getLodIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::ushort 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::ushort)(*arg1)->getLodIndex(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isLodManual(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isLodManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isLodManual();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__setLodInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_setLodInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","_setLodInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setLodInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (*arg1)->_setLodInfo(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__setLodUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  Ogre::MeshLodUsage *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_setLodUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","_setLodUsage", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__MeshLodUsage,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage &","_setLodUsage", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshLodUsage &","_setLodUsage", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::MeshLodUsage * >(argp3);
  (*arg1)->_setLodUsage(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__setSubMeshLodFaceList(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  Ogre::IndexData *arg4 = (Ogre::IndexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_setSubMeshLodFaceList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","_setSubMeshLodFaceList", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","_setSubMeshLodFaceList", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::IndexData *","_setSubMeshLodFaceList", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::IndexData * >(argp4);
  (*arg1)->_setSubMeshLodFaceList(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_removeLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","removeLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->removeLodLevels();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setVertexBufferPolicy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setVertexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setVertexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setVertexBufferPolicy", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (*arg1)->setVertexBufferPolicy(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setVertexBufferPolicy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setVertexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setVertexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  (*arg1)->setVertexBufferPolicy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_setVertexBufferPolicy(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_setVertexBufferPolicy__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MeshSharedPtr_setVertexBufferPolicy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.setVertexBufferPolicy", 
    "    void Mesh.setVertexBufferPolicy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.setVertexBufferPolicy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setIndexBufferPolicy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setIndexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setIndexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setIndexBufferPolicy", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (*arg1)->setIndexBufferPolicy(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setIndexBufferPolicy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setIndexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setIndexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  (*arg1)->setIndexBufferPolicy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_setIndexBufferPolicy(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_setIndexBufferPolicy__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MeshSharedPtr_setIndexBufferPolicy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.setIndexBufferPolicy", 
    "    void Mesh.setIndexBufferPolicy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.setIndexBufferPolicy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getVertexBufferUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareBuffer::Usage 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getVertexBufferUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::HardwareBuffer::Usage)(*arg1)->getVertexBufferUsage();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getIndexBufferUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareBuffer::Usage 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getIndexBufferUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::HardwareBuffer::Usage)(*arg1)->getIndexBufferUsage();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isVertexBufferShadowed(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isVertexBufferShadowed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isVertexBufferShadowed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isIndexBufferShadowed(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isIndexBufferShadowed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isIndexBufferShadowed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__rationaliseBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  size_t arg2 ;
  Ogre::Mesh::VertexBoneAssignmentList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_rationaliseBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_rationaliseBoneAssignments", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Mesh::VertexBoneAssignmentList &","_rationaliseBoneAssignments", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::VertexBoneAssignmentList &","_rationaliseBoneAssignments", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Mesh::VertexBoneAssignmentList * >(argp3);
  result = (unsigned short)(*arg1)->_rationaliseBoneAssignments(arg2,*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__compileBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_compileBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->_compileBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__updateCompiledBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_updateCompiledBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->_updateCompiledBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildTangentVectors__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (*arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildTangentVectors__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  (*arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildTangentVectors__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (*arg1)->buildTangentVectors(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildTangentVectors__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  (*arg1)->buildTangentVectors(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildTangentVectors__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  (*arg1)->buildTangentVectors(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildTangentVectors__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  (*arg1)->buildTangentVectors(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildTangentVectors__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->buildTangentVectors();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_buildTangentVectors(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_buildTangentVectors__SWIG_6(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_buildTangentVectors__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MeshSharedPtr_buildTangentVectors__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshSharedPtr_buildTangentVectors__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(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_MeshSharedPtr_buildTangentVectors__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_MeshSharedPtr_buildTangentVectors__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshSharedPtr_buildTangentVectors__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Mesh.buildTangentVectors", 
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated, bool storeParityInW)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic)\n"
    "    void Mesh.buildTangentVectors()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_suggestTangentVectorBuildParams(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short *arg3 = 0 ;
  unsigned short *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","suggestTangentVectorBuildParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","suggestTangentVectorBuildParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "unsigned short &","suggestTangentVectorBuildParams", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned short &","suggestTangentVectorBuildParams", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< unsigned short * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "unsigned short &","suggestTangentVectorBuildParams", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned short &","suggestTangentVectorBuildParams", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< unsigned short * >(argp4);
  result = (bool)(*arg1)->suggestTangentVectorBuildParams(arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_buildEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","buildEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->buildEdgeList();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_freeEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","freeEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->freeEdgeList();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_prepareForShadowVolume(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","prepareForShadowVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->prepareForShadowVolume();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getEdgeList__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::EdgeData *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","getEdgeList", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::EdgeData *)(*arg1)->getEdgeList(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getEdgeList__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::EdgeData *)(*arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getEdgeList__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::EdgeData *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","getEdgeList", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::EdgeData *)(*arg1)->getEdgeList(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getEdgeList__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::EdgeData *)(*arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_getEdgeList(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_getEdgeList__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_getEdgeList__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_getEdgeList__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_getEdgeList__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getEdgeList", 
    "    Ogre::EdgeData const * Mesh.getEdgeList(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.getEdgeList()\n"
    "    Ogre::EdgeData const * Mesh.getEdgeList(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.getEdgeList()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isPreparedForShadowVolumes(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isPreparedForShadowVolumes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isPreparedForShadowVolumes();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isEdgeListBuilt(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isEdgeListBuilt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isEdgeListBuilt();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_prepareMatricesForVertexBlend(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Matrix4 **arg2 = (Ogre::Matrix4 **) 0 ;
  Ogre::Matrix4 *arg3 = (Ogre::Matrix4 *) 0 ;
  Ogre::Mesh::IndexMap *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","prepareMatricesForVertexBlend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const **","prepareMatricesForVertexBlend", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 ** >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","prepareMatricesForVertexBlend", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap const &","prepareMatricesForVertexBlend", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::IndexMap const &","prepareMatricesForVertexBlend", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp4);
  (*arg1)->prepareMatricesForVertexBlend((Ogre::Matrix4 const **)arg2,(Ogre::Matrix4 const *)arg3,(Ogre::Mesh::IndexMap const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_softwareVertexBlend(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  Ogre::VertexData *arg3 = (Ogre::VertexData *) 0 ;
  Ogre::Matrix4 **arg4 = (Ogre::Matrix4 **) 0 ;
  size_t arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","softwareVertexBlend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData const *","softwareVertexBlend", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexData const *","softwareVertexBlend", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexData * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *const *","softwareVertexBlend", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Matrix4 ** >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","softwareVertexBlend", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","softwareVertexBlend", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  (*arg1)->softwareVertexBlend((Ogre::VertexData const *)arg2,(Ogre::VertexData const *)arg3,(Ogre::Matrix4 const *const *)arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_softwareVertexMorph(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::HardwareVertexBufferSharedPtr *arg3 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg4 = 0 ;
  Ogre::VertexData *arg5 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","softwareVertexMorph", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","softwareVertexMorph", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","softwareVertexMorph", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","softwareVertexMorph", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","softwareVertexMorph", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","softwareVertexMorph", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexData *","softwareVertexMorph", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexData * >(argp5);
  (*arg1)->softwareVertexMorph(arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3,(Ogre::HardwareVertexBufferSharedPtr const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_softwareVertexPoseBlend(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Real arg2 ;
  Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type *arg3 = 0 ;
  Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type *arg4 = 0 ;
  Ogre::VertexData *arg5 = (Ogre::VertexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","softwareVertexPoseBlend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","softwareVertexPoseBlend", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","softwareVertexPoseBlend", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","softwareVertexPoseBlend", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","softwareVertexPoseBlend", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","softwareVertexPoseBlend", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexData *","softwareVertexPoseBlend", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexData * >(argp5);
  (*arg1)->softwareVertexPoseBlend(arg2,(Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &)*arg3,(Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSubMeshNameMap(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh::SubMeshNameMap *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSubMeshNameMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Mesh::SubMeshNameMap *) &(*arg1)->getSubMeshNameMap();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setAutoBuildEdgeLists(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setAutoBuildEdgeLists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoBuildEdgeLists", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setAutoBuildEdgeLists(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getAutoBuildEdgeLists(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getAutoBuildEdgeLists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->getAutoBuildEdgeLists();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSharedVertexDataAnimationType(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexAnimationType 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSharedVertexDataAnimationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::VertexAnimationType)(*arg1)->getSharedVertexDataAnimationType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSharedVertexDataAnimationIncludesNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSharedVertexDataAnimationIncludesNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->getSharedVertexDataAnimationIncludesNormals();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_createAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Animation *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","createAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","createAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Animation *)(*arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getAnimation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)(*arg1)->getAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getAnimation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Animation *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","getAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Animation *)(*arg1)->getAnimation(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_getAnimation(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_getAnimation__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_getAnimation__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getAnimation", 
    "    Ogre::Animation * Mesh.getAnimation(Ogre::String const &name)\n"
    "    Ogre::Animation * Mesh.getAnimation(unsigned short index)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__getAnimationImpl(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","_getAnimationImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","_getAnimationImpl", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getAnimationImpl", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)(*arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_hasAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","hasAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","hasAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(*arg1)->hasAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_removeAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","removeAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","removeAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->removeAnimation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getNumAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getNumAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (unsigned short)(*arg1)->getNumAnimations();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_removeAllAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","removeAllAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->removeAllAnimations();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getVertexDataByTrackHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::VertexData *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getVertexDataByTrackHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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","getVertexDataByTrackHandle", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::VertexData *)(*arg1)->getVertexDataByTrackHandle(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_updateMaterialForAllSubMeshes(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","updateMaterialForAllSubMeshes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->updateMaterialForAllSubMeshes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__determineAnimationTypes(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","_determineAnimationTypes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->_determineAnimationTypes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__getAnimationTypesDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","_getAnimationTypesDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->_getAnimationTypesDirty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_createPose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::Pose *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","createPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","createPose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  {
    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 &","createPose", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPose", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Pose *)(*arg1)->createPose(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_createPose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Pose *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","createPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","createPose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::Pose *)(*arg1)->createPose(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_createPose(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_createPose__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _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_MeshSharedPtr_createPose__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.createPose", 
    "    Ogre::Pose * Mesh.createPose(Ogre::ushort target, Ogre::String const &name)\n"
    "    Ogre::Pose * Mesh.createPose(Ogre::ushort target)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getPoseCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getPoseCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (*arg1)->getPoseCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getPose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Pose *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","getPose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::Pose *)(*arg1)->getPose(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getPose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Pose *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","getPose", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getPose", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Pose *)(*arg1)->getPose((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_getPose(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_getPose__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_getPose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getPose", 
    "    Ogre::Pose * Mesh.getPose(Ogre::ushort index)\n"
    "    Ogre::Pose * Mesh.getPose(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_removePose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","removePose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","removePose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (*arg1)->removePose(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_removePose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","removePose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","removePose", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removePose", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->removePose((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_removePose(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_removePose__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_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_MeshSharedPtr_removePose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.removePose", 
    "    void Mesh.removePose(Ogre::ushort index)\n"
    "    void Mesh.removePose(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_removeAllPoses(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","removeAllPoses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->removeAllPoses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getPoseList(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PoseList *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getPoseList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::PoseList *) &(*arg1)->getPoseList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LodStrategy *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::LodStrategy *)(*arg1)->getLodStrategy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::LodStrategy *arg2 = (Ogre::LodStrategy *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodStrategy *","setLodStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodStrategy * >(argp2);
  (*arg1)->setLodStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","prepare", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->prepare(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_prepare(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_prepare__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_prepare__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.prepare", 
    "    void Resource.prepare(bool backgroundThread)\n"
    "    void Resource.prepare()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","load", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->load(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_load(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_load__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MeshSharedPtr_load__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Resource.load", 
    "    void Resource.load(bool backgroundThread)\n"
    "    void Resource.load()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_reload(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","reload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->reload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isReloadable(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isReloadable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isReloadable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isManuallyLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isManuallyLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isManuallyLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (*arg1)->getSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_touch(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","touch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->touch();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceHandle 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::ResourceHandle)(*arg1)->getHandle();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isPrepared(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isPrepared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isPrepared();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isLoading();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getLoadingState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource::LoadingState 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getLoadingState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::Resource::LoadingState)(*arg1)->getLoadingState();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_isBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","isBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (bool)(*arg1)->isBackgroundLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBackgroundLoaded", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->setBackgroundLoaded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_escalateLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","escalateLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->escalateLoading();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (*arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (*arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_changeGroupOwnership(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","changeGroupOwnership", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","changeGroupOwnership", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","changeGroupOwnership", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->changeGroupOwnership((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getCreator(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceManager *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getCreator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::ResourceManager *)(*arg1)->getCreator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::String *) &(*arg1)->getOrigin();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__notifyOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_notifyOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","_notifyOrigin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyOrigin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (*arg1)->_notifyOrigin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getStateCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getStateCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (*arg1)->getStateCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__dirtyState(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_dirtyState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->_dirtyState();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__fireLoadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_fireLoadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_fireLoadingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->_fireLoadingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__firePreparingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_firePreparingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_firePreparingComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (*arg1)->_firePreparingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr__fireUnloadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","_fireUnloadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->_fireUnloadingComplete();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getParamDictionary__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getParamDictionary__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParamDictionary *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getParamDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::ParamDictionary *)(*arg1)->getParamDictionary();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParamDictionary, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSharedPtr_getParamDictionary(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_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_getParamDictionary__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_MeshSharedPtr_getParamDictionary__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringInterface.getParamDictionary", 
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n"
    "    Ogre::ParamDictionary const * StringInterface.getParamDictionary()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParameterList *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  result = (Ogre::ParameterList *) &(*arg1)->getParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__ParameterDef_Ogre__STLAllocatorT_Ogre__ParameterDef_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_setParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","setParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 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 &","setParameter", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setParameter", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)(*arg1)->setParameter((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  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_MeshSharedPtr_setParameterList(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::NameValuePairList *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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","setParameterList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::NameValuePairList const &","setParameterList", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::NameValuePairList * >(argp2);
  (*arg1)->setParameterList((Ogre::NameValuePairList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_getParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","getParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(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( "", "Ogre::String const &","getParameter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getParameter", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (*arg1)->getParameter((Ogre::String const &)*arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_copyParametersTo(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 0 ;
  Ogre::StringInterface *arg2 = (Ogre::StringInterface *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > const *","copyParametersTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__StringInterface, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringInterface *","copyParametersTo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::StringInterface * >(argp2);
  (*arg1)->copyParametersTo(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSharedPtr_cleanupDictionary(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedPtr< Ogre::Mesh > *arg1 = (Ogre::SharedPtr< Ogre::Mesh > *) 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_Ogre__SharedPtrT_Ogre__Mesh_t, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedPtr< Ogre::Mesh > *","cleanupDictionary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedPtr< Ogre::Mesh > * >(argp1);
  (*arg1)->cleanupDictionary();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMesh;

SWIGINTERN VALUE
_wrap_new_Mesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Mesh";
  Ogre::Mesh *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Mesh", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Mesh", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Mesh", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Mesh", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Mesh", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Mesh", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Mesh", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","Ogre::Mesh", 6, argv[5] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::Mesh *)new Ogre::Mesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Mesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Mesh";
  Ogre::Mesh *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Mesh", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Mesh", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Mesh", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Mesh", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Mesh", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Mesh", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Mesh", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::Mesh *)new Ogre::Mesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Mesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Mesh";
  Ogre::Mesh *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Mesh", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Mesh", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Mesh", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Mesh", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Mesh", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Mesh", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::Mesh *)new Ogre::Mesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Mesh(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Mesh__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Mesh__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Mesh__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Mesh.new", 
    "    Mesh.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Mesh.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual)\n"
    "    Mesh.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Mesh(Ogre::Mesh *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Mesh_createSubMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SubMesh *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","createSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::SubMesh *)(arg1)->createSubMesh();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_createSubMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SubMesh *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","createSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","createSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SubMesh *)(arg1)->createSubMesh((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_createSubMesh(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Mesh_createSubMesh__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_Mesh_createSubMesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.createSubMesh", 
    "    Ogre::SubMesh * Mesh.createSubMesh()\n"
    "    Ogre::SubMesh * Mesh.createSubMesh(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_nameSubMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","nameSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","nameSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","nameSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","nameSubMesh", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->nameSubMesh((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_unnameSubMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","unnameSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","unnameSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unnameSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unnameSubMesh((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__getSubMeshIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ushort 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","_getSubMeshIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","_getSubMeshIndex", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getSubMeshIndex", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ushort)((Ogre::Mesh const *)arg1)->_getSubMeshIndex((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getNumSubMeshes(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getNumSubMeshes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (unsigned short)((Ogre::Mesh const *)arg1)->getNumSubMeshes();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSubMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::SubMesh *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","getSubMesh", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::SubMesh *)((Ogre::Mesh const *)arg1)->getSubMesh(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSubMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SubMesh *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","getSubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SubMesh *)((Ogre::Mesh const *)arg1)->getSubMesh((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_getSubMesh(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_getSubMesh__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_Mesh_getSubMesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getSubMesh", 
    "    Ogre::SubMesh * Mesh.getSubMesh(unsigned short index)\n"
    "    Ogre::SubMesh * Mesh.getSubMesh(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_destroySubMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","destroySubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","destroySubMesh", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->destroySubMesh(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_destroySubMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","destroySubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","destroySubMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroySubMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroySubMesh((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_destroySubMesh(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_destroySubMesh__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_Mesh_destroySubMesh__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.destroySubMesh", 
    "    void Mesh.destroySubMesh(unsigned short index)\n"
    "    void Mesh.destroySubMesh(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSubMeshIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::SubMesh *,Ogre::STLAllocator< Ogre::SubMesh *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","getSubMeshIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (arg1)->getSubMeshIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Mesh::SubMeshIterator(static_cast< const Ogre::Mesh::SubMeshIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_sharedVertexData_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","sharedVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","sharedVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  if (arg1) (arg1)->sharedVertexData = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_sharedVertexData_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","sharedVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::VertexData *) ((arg1)->sharedVertexData);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_sharedBlendIndexToBoneIndexMap_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::Mesh::IndexMap *arg2 = (Ogre::Mesh::IndexMap *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","sharedBlendIndexToBoneIndexMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap *","sharedBlendIndexToBoneIndexMap", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp2);
  if (arg1) (arg1)->sharedBlendIndexToBoneIndexMap = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_sharedBlendIndexToBoneIndexMap_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh::IndexMap *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","sharedBlendIndexToBoneIndexMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::Mesh::IndexMap *)& ((arg1)->sharedBlendIndexToBoneIndexMap);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_clone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 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 &","clone", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->clone((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  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_Mesh_clone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->clone((Ogre::String const &)*arg2);
  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_Mesh_clone(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_Ogre__Mesh, 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_Mesh_clone__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_Mesh_clone__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.clone", 
    "    Ogre::MeshPtr Mesh.clone(Ogre::String const &newName, Ogre::String const &newGroup)\n"
    "    Ogre::MeshPtr Mesh.clone(Ogre::String const &newName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::Mesh const *)arg1)->getBounds();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getBoundingSphereRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getBoundingSphereRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::Real)((Ogre::Mesh const *)arg1)->getBoundingSphereRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__setBounds__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_setBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setBounds", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__setBounds__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_setBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","_setBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->_setBounds((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh__setBounds(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Mesh__setBounds__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Mesh__setBounds__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh._setBounds", 
    "    void Mesh._setBounds(Ogre::AxisAlignedBox const &bounds, bool pad)\n"
    "    void Mesh._setBounds(Ogre::AxisAlignedBox const &bounds)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__setBoundingSphereRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_setBoundingSphereRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_setBoundingSphereRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->_setBoundingSphereRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_setSkeletonName(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","setSkeletonName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","setSkeletonName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkeletonName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSkeletonName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_hasSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","hasSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->hasSkeleton();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_hasVertexAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","hasVertexAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->hasVertexAnimation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonPtr *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::SkeletonPtr *) &((Ogre::Mesh const *)arg1)->getSkeleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSkeletonName(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getSkeletonName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::String *) &((Ogre::Mesh const *)arg1)->getSkeletonName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__initAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_initAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_initAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (arg1)->_initAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__refreshAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_refreshAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_refreshAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (arg1)->_refreshAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_addBoneAssignment(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexBoneAssignment *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","addBoneAssignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__VertexBoneAssignment_s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment const &","addBoneAssignment", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexBoneAssignment const &","addBoneAssignment", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBoneAssignment * >(argp2);
  (arg1)->addBoneAssignment((Ogre::VertexBoneAssignment const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_clearBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","clearBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->clearBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__notifySkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::SkeletonPtr *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_notifySkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SkeletonPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SkeletonPtr &","_notifySkeleton", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SkeletonPtr &","_notifySkeleton", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::SkeletonPtr * >(argp2);
  (arg1)->_notifySkeleton(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getBoneAssignmentIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::multimap< size_t,Ogre::VertexBoneAssignment,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::VertexBoneAssignment >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","getBoneAssignmentIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (arg1)->getBoneAssignmentIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Mesh::BoneAssignmentIterator(static_cast< const Ogre::Mesh::BoneAssignmentIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh::VertexBoneAssignmentList *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::Mesh::VertexBoneAssignmentList *) &((Ogre::Mesh const *)arg1)->getBoneAssignments();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getNumLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getNumLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::ushort)((Ogre::Mesh const *)arg1)->getNumLodLevels();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getLodLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::MeshLodUsage *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","getLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::MeshLodUsage *) &((Ogre::Mesh const *)arg1)->getLodLevel(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshLodUsage, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_createManualLodLevel__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::Real arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","createManualLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createManualLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    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 &","createManualLodLevel", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManualLodLevel", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createManualLodLevel", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManualLodLevel", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_createManualLodLevel__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::Real arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","createManualLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","createManualLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  {
    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 &","createManualLodLevel", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManualLodLevel", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->createManualLodLevel(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_createManualLodLevel(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _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_Mesh_createManualLodLevel__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Mesh_createManualLodLevel__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Mesh.createManualLodLevel", 
    "    void Mesh.createManualLodLevel(Ogre::Real value, Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    void Mesh.createManualLodLevel(Ogre::Real value, Ogre::String const &meshName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_updateManualLodLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","updateManualLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","updateManualLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  {
    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 &","updateManualLodLevel", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","updateManualLodLevel", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->updateManualLodLevel(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getLodIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::ushort 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::ushort)((Ogre::Mesh const *)arg1)->getLodIndex(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_isLodManual(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","isLodManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->isLodManual();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__setLodInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_setLodInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","_setLodInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setLodInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_setLodInfo(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__setLodUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  Ogre::MeshLodUsage *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_setLodUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","_setLodUsage", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__MeshLodUsage,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage &","_setLodUsage", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshLodUsage &","_setLodUsage", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::MeshLodUsage * >(argp3);
  (arg1)->_setLodUsage(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__setSubMeshLodFaceList(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  Ogre::IndexData *arg4 = (Ogre::IndexData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_setSubMeshLodFaceList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","_setSubMeshLodFaceList", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","_setSubMeshLodFaceList", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::IndexData *","_setSubMeshLodFaceList", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::IndexData * >(argp4);
  (arg1)->_setSubMeshLodFaceList(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_removeLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","removeLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->removeLodLevels();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_setVertexBufferPolicy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","setVertexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setVertexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setVertexBufferPolicy", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setVertexBufferPolicy(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_setVertexBufferPolicy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","setVertexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setVertexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  (arg1)->setVertexBufferPolicy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_setVertexBufferPolicy(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_setVertexBufferPolicy__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Mesh_setVertexBufferPolicy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.setVertexBufferPolicy", 
    "    void Mesh.setVertexBufferPolicy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.setVertexBufferPolicy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_setIndexBufferPolicy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","setIndexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setIndexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setIndexBufferPolicy", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setIndexBufferPolicy(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_setIndexBufferPolicy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","setIndexBufferPolicy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","setIndexBufferPolicy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  (arg1)->setIndexBufferPolicy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_setIndexBufferPolicy(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_setIndexBufferPolicy__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Mesh_setIndexBufferPolicy__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.setIndexBufferPolicy", 
    "    void Mesh.setIndexBufferPolicy(Ogre::HardwareBuffer::Usage usage, bool shadowBuffer)\n"
    "    void Mesh.setIndexBufferPolicy(Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getVertexBufferUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareBuffer::Usage 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getVertexBufferUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::HardwareBuffer::Usage)((Ogre::Mesh const *)arg1)->getVertexBufferUsage();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getIndexBufferUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareBuffer::Usage 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getIndexBufferUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::HardwareBuffer::Usage)((Ogre::Mesh const *)arg1)->getIndexBufferUsage();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_isVertexBufferShadowed(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","isVertexBufferShadowed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->isVertexBufferShadowed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_isIndexBufferShadowed(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","isIndexBufferShadowed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->isIndexBufferShadowed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__rationaliseBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  size_t arg2 ;
  Ogre::Mesh::VertexBoneAssignmentList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned short 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_rationaliseBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_rationaliseBoneAssignments", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Mesh::VertexBoneAssignmentList &","_rationaliseBoneAssignments", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::VertexBoneAssignmentList &","_rationaliseBoneAssignments", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Mesh::VertexBoneAssignmentList * >(argp3);
  result = (unsigned short)(arg1)->_rationaliseBoneAssignments(arg2,*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__compileBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_compileBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->_compileBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__updateCompiledBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","_updateCompiledBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->_updateCompiledBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildTangentVectors__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildTangentVectors__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->buildTangentVectors(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildTangentVectors__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","buildTangentVectors", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->buildTangentVectors(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildTangentVectors__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  (arg1)->buildTangentVectors(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildTangentVectors__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","buildTangentVectors", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  (arg1)->buildTangentVectors(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildTangentVectors__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","buildTangentVectors", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  (arg1)->buildTangentVectors(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildTangentVectors__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildTangentVectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->buildTangentVectors();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_buildTangentVectors(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Mesh_buildTangentVectors__SWIG_6(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_buildTangentVectors__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Mesh_buildTangentVectors__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Mesh_buildTangentVectors__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(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_Mesh_buildTangentVectors__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Mesh_buildTangentVectors__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Mesh_buildTangentVectors__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Mesh.buildTangentVectors", 
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated, bool storeParityInW)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored, bool splitRotated)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index, bool splitMirrored)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet)\n"
    "    void Mesh.buildTangentVectors(Ogre::VertexElementSemantic targetSemantic)\n"
    "    void Mesh.buildTangentVectors()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_suggestTangentVectorBuildParams(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short *arg3 = 0 ;
  unsigned short *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","suggestTangentVectorBuildParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","suggestTangentVectorBuildParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "unsigned short &","suggestTangentVectorBuildParams", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned short &","suggestTangentVectorBuildParams", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< unsigned short * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_unsigned_short,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "unsigned short &","suggestTangentVectorBuildParams", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned short &","suggestTangentVectorBuildParams", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< unsigned short * >(argp4);
  result = (bool)(arg1)->suggestTangentVectorBuildParams(arg2,*arg3,*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_buildEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","buildEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->buildEdgeList();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_freeEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","freeEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->freeEdgeList();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_prepareForShadowVolume(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","prepareForShadowVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->prepareForShadowVolume();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getEdgeList__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::EdgeData *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","getEdgeList", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::EdgeData *)(arg1)->getEdgeList(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getEdgeList__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::EdgeData *)(arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getEdgeList__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::EdgeData *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","getEdgeList", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::EdgeData *)((Ogre::Mesh const *)arg1)->getEdgeList(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getEdgeList__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::EdgeData *)((Ogre::Mesh const *)arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_getEdgeList(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Mesh_getEdgeList__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Mesh_getEdgeList__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_getEdgeList__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_getEdgeList__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getEdgeList", 
    "    Ogre::EdgeData const * Mesh.getEdgeList(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.getEdgeList()\n"
    "    Ogre::EdgeData const * Mesh.getEdgeList(unsigned short lodIndex)\n"
    "    Ogre::EdgeData const * Mesh.getEdgeList()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_isPreparedForShadowVolumes(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","isPreparedForShadowVolumes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->isPreparedForShadowVolumes();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_isEdgeListBuilt(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","isEdgeListBuilt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->isEdgeListBuilt();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_prepareMatricesForVertexBlend(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 **arg1 = (Ogre::Matrix4 **) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 0 ;
  Ogre::Mesh::IndexMap *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const **","Ogre::Mesh::prepareMatricesForVertexBlend", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 ** >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","Ogre::Mesh::prepareMatricesForVertexBlend", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap const &","Ogre::Mesh::prepareMatricesForVertexBlend", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::IndexMap const &","Ogre::Mesh::prepareMatricesForVertexBlend", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp3);
  Ogre::Mesh::prepareMatricesForVertexBlend((Ogre::Matrix4 const **)arg1,(Ogre::Matrix4 const *)arg2,(Ogre::vector< unsigned short,Ogre::STLAllocator< unsigned short,Ogre::GeneralAllocPolicy > >::type const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_softwareVertexBlend(int argc, VALUE *argv, VALUE self) {
  Ogre::VertexData *arg1 = (Ogre::VertexData *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  Ogre::Matrix4 **arg3 = (Ogre::Matrix4 **) 0 ;
  size_t arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VertexData const *","Ogre::Mesh::softwareVertexBlend", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::VertexData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData const *","Ogre::Mesh::softwareVertexBlend", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *const *","Ogre::Mesh::softwareVertexBlend", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 ** >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::Mesh::softwareVertexBlend", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Mesh::softwareVertexBlend", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  Ogre::Mesh::softwareVertexBlend((Ogre::VertexData const *)arg1,(Ogre::VertexData const *)arg2,(Ogre::Matrix4 const *const *)arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_softwareVertexMorph(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg3 = 0 ;
  Ogre::VertexData *arg4 = (Ogre::VertexData *) 0 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 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","Ogre::Mesh::softwareVertexMorph", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","Ogre::Mesh::softwareVertexMorph", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","Ogre::Mesh::softwareVertexMorph", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","Ogre::Mesh::softwareVertexMorph", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","Ogre::Mesh::softwareVertexMorph", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VertexData *","Ogre::Mesh::softwareVertexMorph", 4, argv[3] )); 
  }
  arg4 = reinterpret_cast< Ogre::VertexData * >(argp4);
  Ogre::Mesh::softwareVertexMorph(arg1,(Ogre::HardwareVertexBufferSharedPtr const &)*arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_softwareVertexPoseBlend(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type *arg2 = 0 ;
  Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type *arg3 = 0 ;
  Ogre::VertexData *arg4 = (Ogre::VertexData *) 0 ;
  float val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 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","Ogre::Mesh::softwareVertexPoseBlend", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Mesh::softwareVertexPoseBlend", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Mesh::softwareVertexPoseBlend", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Mesh::softwareVertexPoseBlend", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &","Ogre::Mesh::softwareVertexPoseBlend", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VertexData *","Ogre::Mesh::softwareVertexPoseBlend", 4, argv[3] )); 
  }
  arg4 = reinterpret_cast< Ogre::VertexData * >(argp4);
  Ogre::Mesh::softwareVertexPoseBlend(arg1,(Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &)*arg2,(Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSubMeshNameMap(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh::SubMeshNameMap *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getSubMeshNameMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::Mesh::SubMeshNameMap *) &((Ogre::Mesh const *)arg1)->getSubMeshNameMap();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_setAutoBuildEdgeLists(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","setAutoBuildEdgeLists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoBuildEdgeLists", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoBuildEdgeLists(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getAutoBuildEdgeLists(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getAutoBuildEdgeLists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->getAutoBuildEdgeLists();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSharedVertexDataAnimationType(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexAnimationType 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getSharedVertexDataAnimationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::VertexAnimationType)((Ogre::Mesh const *)arg1)->getSharedVertexDataAnimationType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getSharedVertexDataAnimationIncludesNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getSharedVertexDataAnimationIncludesNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->getSharedVertexDataAnimationIncludesNormals();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_createAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Animation *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","createAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","createAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getAnimation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::Mesh const *)arg1)->getAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__getAnimationImpl(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","_getAnimationImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","_getAnimationImpl", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getAnimationImpl", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::Mesh const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_hasAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","hasAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","hasAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::Mesh const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_removeAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","removeAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","removeAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeAnimation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getNumAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getNumAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (unsigned short)((Ogre::Mesh const *)arg1)->getNumAnimations();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getAnimation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Animation *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","getAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Animation *)((Ogre::Mesh const *)arg1)->getAnimation(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_getAnimation(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_getAnimation__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_Mesh_getAnimation__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getAnimation", 
    "    Ogre::Animation * Mesh.getAnimation(Ogre::String const &name)\n"
    "    Ogre::Animation * Mesh.getAnimation(unsigned short index)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_removeAllAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","removeAllAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->removeAllAnimations();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getVertexDataByTrackHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::VertexData *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","getVertexDataByTrackHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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","getVertexDataByTrackHandle", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::VertexData *)(arg1)->getVertexDataByTrackHandle(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_updateMaterialForAllSubMeshes(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","updateMaterialForAllSubMeshes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->updateMaterialForAllSubMeshes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__determineAnimationTypes(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","_determineAnimationTypes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ((Ogre::Mesh const *)arg1)->_determineAnimationTypes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh__getAnimationTypesDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","_getAnimationTypesDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)((Ogre::Mesh const *)arg1)->_getAnimationTypesDirty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_createPose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::Pose *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","createPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","createPose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  {
    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 &","createPose", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPose", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Pose *)(arg1)->createPose(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_createPose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Pose *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","createPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","createPose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::Pose *)(arg1)->createPose(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_createPose(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_createPose__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _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_Mesh_createPose__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Mesh.createPose", 
    "    Ogre::Pose * Mesh.createPose(Ogre::ushort target, Ogre::String const &name)\n"
    "    Ogre::Pose * Mesh.createPose(Ogre::ushort target)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getPoseCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getPoseCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = ((Ogre::Mesh const *)arg1)->getPoseCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getPose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Pose *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","getPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","getPose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::Pose *)(arg1)->getPose(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getPose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Pose *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","getPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","getPose", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getPose", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Pose *)(arg1)->getPose((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pose, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_getPose(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_getPose__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_Mesh_getPose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.getPose", 
    "    Ogre::Pose * Mesh.getPose(Ogre::ushort index)\n"
    "    Ogre::Pose * Mesh.getPose(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_removePose__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","removePose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","removePose", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->removePose(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_removePose__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","removePose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(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( "", "Ogre::String const &","removePose", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removePose", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removePose((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Mesh_removePose(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_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Mesh_removePose__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_Mesh_removePose__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Mesh.removePose", 
    "    void Mesh.removePose(Ogre::ushort index)\n"
    "    void Mesh.removePose(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_removeAllPoses(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","removeAllPoses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  (arg1)->removeAllPoses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getPoseList(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PoseList *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getPoseList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::PoseList *) &((Ogre::Mesh const *)arg1)->getPoseList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Pose_p_Ogre__STLAllocatorT_Ogre__Pose_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_getLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LodStrategy *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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh const *","getLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::LodStrategy *)((Ogre::Mesh const *)arg1)->getLodStrategy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Mesh_setLodStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  Ogre::LodStrategy *arg2 = (Ogre::LodStrategy *) 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_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","setLodStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodStrategy *","setLodStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodStrategy * >(argp2);
  (arg1)->setLodStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMeshPtr;

SWIGINTERN VALUE
_wrap_new_MeshPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MeshPtr";
  Ogre::MeshPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MeshPtr *)new Ogre::MeshPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MeshPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MeshPtr";
  Ogre::MeshPtr *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__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","Ogre::MeshPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (Ogre::MeshPtr *)new Ogre::MeshPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_MeshPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MeshPtr";
  Ogre::MeshPtr *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__MeshPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshPtr const &","Ogre::MeshPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshPtr const &","Ogre::MeshPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::MeshPtr * >(argp1);
  result = (Ogre::MeshPtr *)new Ogre::MeshPtr((Ogre::MeshPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MeshPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::MeshPtr";
  Ogre::MeshPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::MeshPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::MeshPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::MeshPtr *)new Ogre::MeshPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_MeshPtr(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_MeshPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MeshPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MeshPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_MeshPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "MeshPtr.new", 
    "    MeshPtr.new()\n"
    "    MeshPtr.new(Ogre::Mesh *rep)\n"
    "    MeshPtr.new(Ogre::MeshPtr const &r)\n"
    "    MeshPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_MeshPtr(Ogre::MeshPtr *arg1) {
    delete arg1;
}

swig_class SwigClassMeshLodUsage;

SWIGINTERN VALUE
_wrap_MeshLodUsage_userValue_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","userValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","userValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->userValue = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_userValue_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","userValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  result = (Ogre::Real) ((arg1)->userValue);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_value_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","value", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","value", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->value = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_value_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","value", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  result = (Ogre::Real) ((arg1)->value);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_manualName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  Ogre::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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","manualName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(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( "", "Ogre::String const &","manualName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","manualName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->manualName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_manualName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","manualName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  result = (Ogre::String *) & ((arg1)->manualName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_manualGroup_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  Ogre::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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","manualGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(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( "", "Ogre::String const &","manualGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","manualGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->manualGroup = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_manualGroup_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","manualGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  result = (Ogre::String *) & ((arg1)->manualGroup);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_manualMesh_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  Ogre::MeshPtr *arg2 = (Ogre::MeshPtr *) 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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","manualMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshPtr *","manualMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MeshPtr * >(argp2);
  if (arg1) (arg1)->manualMesh = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_manualMesh_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr *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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","manualMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  result = (Ogre::MeshPtr *)& ((arg1)->manualMesh);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_edgeData_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  Ogre::EdgeData *arg2 = (Ogre::EdgeData *) 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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","edgeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__EdgeData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EdgeData *","edgeData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::EdgeData * >(argp2);
  if (arg1) (arg1)->edgeData = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshLodUsage_edgeData_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshLodUsage *arg1 = (Ogre::MeshLodUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__MeshLodUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshLodUsage *","edgeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshLodUsage * >(argp1);
  result = (Ogre::EdgeData *) ((arg1)->edgeData);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MeshLodUsage(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MeshLodUsage";
  Ogre::MeshLodUsage *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MeshLodUsage *)new Ogre::MeshLodUsage();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MeshLodUsage(Ogre::MeshLodUsage *arg1) {
    delete arg1;
}

swig_class SwigClassNode;

SWIGINTERN void
free_Ogre_Node(Ogre::Node *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Node_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::String *) &((Ogre::Node const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Node *)((Ogre::Node const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Node const *)arg1)->getOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setOrientation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Quaternion *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setOrientation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOrientation", 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","setOrientation", 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","setOrientation", 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","setOrientation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setOrientation(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_setOrientation(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Node_setOrientation__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Node_setOrientation__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Node.setOrientation", 
    "    void Node.setOrientation(Ogre::Quaternion const &q)\n"
    "    void Node.setOrientation(Ogre::Real w, Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_resetOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","resetOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  (arg1)->resetOrientation();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->setPosition(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_setPosition(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_Ogre__Node, 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_Node_setPosition__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_setPosition__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.setPosition", 
    "    void Node.setPosition(Ogre::Vector3 const &pos)\n"
    "    void Node.setPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setScale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->setScale((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setScale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->setScale(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_setScale(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_Ogre__Node, 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_Node_setScale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_setScale__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.setScale", 
    "    void Node.setScale(Ogre::Vector3 const &scale)\n"
    "    void Node.setScale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getScale();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setInheritOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setInheritOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInheritOrientation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setInheritOrientation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getInheritOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getInheritOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (bool)((Ogre::Node const *)arg1)->getInheritOrientation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setInheritScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setInheritScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInheritScale", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setInheritScale(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getInheritScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getInheritScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (bool)((Ogre::Node const *)arg1)->getInheritScale();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->scale((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","scale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->scale(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_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_Ogre__Node, 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_Node_scale__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_scale__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.scale", 
    "    void Node.scale(Ogre::Vector3 const &scale)\n"
    "    void Node.scale(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","translate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->translate((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->translate((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Node::TransformSpace 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 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","translate", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Node::TransformSpace >(val5);
  (arg1)->translate(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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);
  (arg1)->translate(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Node::TransformSpace arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","translate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","translate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(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 &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","translate", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Node::TransformSpace >(val4);
  (arg1)->translate((Ogre::Matrix3 const &)*arg2,(Ogre::Vector3 const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Matrix3 *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","translate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","translate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(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 &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->translate((Ogre::Matrix3 const &)*arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Node::TransformSpace arg6 ;
  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 ;
  int val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","translate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","translate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  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);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","translate", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","translate", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Node::TransformSpace >(val6);
  (arg1)->translate((Ogre::Matrix3 const &)*arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_translate__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  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 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","translate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","translate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  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);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","translate", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->translate((Ogre::Matrix3 const &)*arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_translate(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__Node, 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_Node_translate__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_translate__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 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_Node_translate__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Node_translate__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_translate__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 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_Node_translate__SWIG_7(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_translate__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 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) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Node_translate__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Node.translate", 
    "    void Node.translate(Ogre::Vector3 const &d, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.translate(Ogre::Vector3 const &d)\n"
    "    void Node.translate(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.translate(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Node.translate(Ogre::Matrix3 const &axes, Ogre::Vector3 const &move, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.translate(Ogre::Matrix3 const &axes, Ogre::Vector3 const &move)\n"
    "    void Node.translate(Ogre::Matrix3 const &axes, Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.translate(Ogre::Matrix3 const &axes, Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_roll__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","roll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 const &","roll", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","roll", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","roll", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->roll((Ogre::Radian const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_roll__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Radian *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","roll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 const &","roll", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","roll", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->roll((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_roll(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Node_roll__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Node_roll__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Node.roll", 
    "    void Node.roll(Ogre::Radian const &angle, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.roll(Ogre::Radian const &angle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_pitch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","pitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 const &","pitch", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","pitch", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","pitch", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->pitch((Ogre::Radian const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_pitch__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Radian *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","pitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 const &","pitch", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","pitch", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->pitch((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_pitch(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Node_pitch__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Node_pitch__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Node.pitch", 
    "    void Node.pitch(Ogre::Radian const &angle, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.pitch(Ogre::Radian const &angle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_yaw__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","yaw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 const &","yaw", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","yaw", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","yaw", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->yaw((Ogre::Radian const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_yaw__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Radian *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","yaw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 const &","yaw", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","yaw", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->yaw((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_yaw(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Node_yaw__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Node_yaw__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Node.yaw", 
    "    void Node.yaw(Ogre::Radian const &angle, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.yaw(Ogre::Radian const &angle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_rotate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Radian *arg3 = 0 ;
  Ogre::Node::TransformSpace arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","rotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","rotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","rotate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","rotate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","rotate", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Node::TransformSpace >(val4);
  (arg1)->rotate((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_rotate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Radian *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","rotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","rotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","rotate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","rotate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  (arg1)->rotate((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_rotate__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","rotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","rotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","rotate", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->rotate((Ogre::Quaternion const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_rotate__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Quaternion *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","rotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","rotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->rotate((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_rotate(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Node_rotate__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Node_rotate__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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__Radian, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Node_rotate__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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__Radian, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Node_rotate__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.rotate", 
    "    void Node.rotate(Ogre::Vector3 const &axis, Ogre::Radian const &angle, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.rotate(Ogre::Vector3 const &axis, Ogre::Radian const &angle)\n"
    "    void Node.rotate(Ogre::Quaternion const &q, Ogre::Node::TransformSpace relativeTo)\n"
    "    void Node.rotate(Ogre::Quaternion const &q)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getLocalAxes(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix3 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getLocalAxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = ((Ogre::Node const *)arg1)->getLocalAxes();
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_createChild__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","createChild", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChild", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createChild", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createChild", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  result = (Ogre::Node *)(arg1)->createChild((Ogre::Vector3 const &)*arg2,(Ogre::Quaternion const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_createChild__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","createChild", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChild", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Node *)(arg1)->createChild((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_createChild__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Node *)(arg1)->createChild();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_createChild__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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( "", "Ogre::String const &","createChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  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 &","createChild", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChild", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createChild", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createChild", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  result = (Ogre::Node *)(arg1)->createChild((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_createChild__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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( "", "Ogre::String const &","createChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  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 &","createChild", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChild", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = (Ogre::Node *)(arg1)->createChild((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_createChild__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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( "", "Ogre::String const &","createChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Node *)(arg1)->createChild((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_createChild(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Node_createChild__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_createChild__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_createChild__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Node_createChild__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(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_Node_createChild__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(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__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Node_createChild__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Node.createChild", 
    "    Ogre::Node * Node.createChild(Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::Node * Node.createChild(Ogre::Vector3 const &translate)\n"
    "    Ogre::Node * Node.createChild()\n"
    "    Ogre::Node * Node.createChild(Ogre::String const &name, Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::Node * Node.createChild(Ogre::String const &name, Ogre::Vector3 const &translate)\n"
    "    Ogre::Node * Node.createChild(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_addChild(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","addChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","addChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->addChild(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_numChildren(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","numChildren", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (unsigned short)((Ogre::Node const *)arg1)->numChildren();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getChild__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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","getChild", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Node *)((Ogre::Node const *)arg1)->getChild(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getChild__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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( "", "Ogre::String const &","getChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Node *)((Ogre::Node const *)arg1)->getChild((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_getChild(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Node_getChild__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_getChild__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Node.getChild", 
    "    Ogre::Node * Node.getChild(unsigned short index)\n"
    "    Ogre::Node * Node.getChild(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_removeChild__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","removeChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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","removeChild", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Node *)(arg1)->removeChild(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_removeChild__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","removeChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","removeChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  result = (Ogre::Node *)(arg1)->removeChild(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_removeChild__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Node *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","removeChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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( "", "Ogre::String const &","removeChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Node *)(arg1)->removeChild((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_removeChild(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Node_removeChild__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Node_removeChild__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 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_Node_removeChild__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Node.removeChild", 
    "    Ogre::Node * Node.removeChild(unsigned short index)\n"
    "    Ogre::Node * Node.removeChild(Ogre::Node *child)\n"
    "    Ogre::Node * Node.removeChild(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_removeAllChildren(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","removeAllChildren", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  (arg1)->removeAllChildren();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node__setDerivedPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","_setDerivedPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","_setDerivedPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","_setDerivedPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->_setDerivedPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node__setDerivedOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Quaternion *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","_setDerivedOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","_setDerivedOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setDerivedOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->_setDerivedOrientation((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node__getDerivedOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","_getDerivedOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Node const *)arg1)->_getDerivedOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node__getDerivedPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","_getDerivedPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->_getDerivedPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node__getDerivedScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","_getDerivedScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->_getDerivedScale();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node__getFullTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","_getFullTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::Node const *)arg1)->_getFullTransform();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node__update(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","_update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_update", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_update", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_update(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Node::Listener *arg2 = (Ogre::Node::Listener *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node::Listener *","setListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node::Listener * >(argp2);
  (arg1)->setListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Node::Listener *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Node::Listener *)((Ogre::Node const *)arg1)->getListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node__Listener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setInitialState(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setInitialState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  (arg1)->setInitialState();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_resetToInitialState(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","resetToInitialState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  (arg1)->resetToInitialState();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getInitialPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getInitialPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getInitialPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_convertWorldToLocalPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","convertWorldToLocalPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","convertWorldToLocalPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertWorldToLocalPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (arg1)->convertWorldToLocalPosition((Ogre::Vector3 const &)*arg2);
  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_Node_convertLocalToWorldPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","convertLocalToWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","convertLocalToWorldPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertLocalToWorldPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (arg1)->convertLocalToWorldPosition((Ogre::Vector3 const &)*arg2);
  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_Node_convertWorldToLocalOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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(self, &argp1,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","convertWorldToLocalOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","convertWorldToLocalOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","convertWorldToLocalOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = (arg1)->convertWorldToLocalOrientation((Ogre::Quaternion const &)*arg2);
  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_Node_convertLocalToWorldOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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(self, &argp1,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","convertLocalToWorldOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(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 &","convertLocalToWorldOrientation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","convertLocalToWorldOrientation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = (arg1)->convertLocalToWorldOrientation((Ogre::Quaternion const &)*arg2);
  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_Node_getInitialOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getInitialOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Node const *)arg1)->getInitialOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getInitialScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getInitialScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Node const *)arg1)->getInitialScale();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::Node const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_needUpdate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","needUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","needUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->needUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_needUpdate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","needUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  (arg1)->needUpdate();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_needUpdate(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Node_needUpdate__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Node_needUpdate__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Node.needUpdate", 
    "    void Node.needUpdate(bool forceParentUpdate)\n"
    "    void Node.needUpdate()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_requestUpdate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","requestUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","requestUpdate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","requestUpdate", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->requestUpdate(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_requestUpdate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","requestUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","requestUpdate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->requestUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_requestUpdate(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Node_requestUpdate__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Node_requestUpdate__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Node.requestUpdate", 
    "    void Node.requestUpdate(Ogre::Node *child, bool forceParentUpdate)\n"
    "    void Node.requestUpdate(Ogre::Node *child)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_cancelUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","cancelUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","cancelUpdate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->cancelUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getDebugRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Node::DebugRenderable *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","getDebugRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getDebugRenderable", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Node::DebugRenderable *)(arg1)->getDebugRenderable(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node__DebugRenderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_queueNeedUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","Ogre::Node::queueNeedUpdate", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  Ogre::Node::queueNeedUpdate(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_processQueuedUpdates(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::Node::processQueuedUpdates();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_setUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  Ogre::Any *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","setUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any const &","setUserAny", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","setUserAny", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  (arg1)->setUserAny((Ogre::Any const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getUserAny(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getUserAny", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::Any *) &((Ogre::Node const *)arg1)->getUserAny();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getUserObjectBindings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Node_getUserObjectBindings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Node *arg1 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Node const *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Node * >(argp1);
  result = (Ogre::UserObjectBindings *) &((Ogre::Node const *)arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Node_getUserObjectBindings(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_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Node_getUserObjectBindings__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Node, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Node_getUserObjectBindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Node.getUserObjectBindings", 
    "    Ogre::UserObjectBindings const & Node.getUserObjectBindings()\n"
    "    Ogre::UserObjectBindings const & Node.getUserObjectBindings()\n");
  
  return Qnil;
}


swig_class SwigClassBone;

SWIGINTERN VALUE
_wrap_new_Bone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  unsigned short arg1 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Bone";
  Ogre::Bone *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned short","Ogre::Bone", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned short >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton *","Ogre::Bone", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  result = (Ogre::Bone *)new Ogre::Bone(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Bone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  unsigned short arg2 ;
  Ogre::Skeleton *arg3 = (Ogre::Skeleton *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Bone";
  Ogre::Bone *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Bone", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Bone", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::Bone", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Skeleton *","Ogre::Bone", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::Skeleton * >(argp3);
  result = (Ogre::Bone *)new Ogre::Bone((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Bone(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 == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Bone__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Bone__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Bone.new", 
    "    Bone.new(unsigned short handle, Ogre::Skeleton *creator)\n"
    "    Bone.new(Ogre::String const &name, unsigned short handle, Ogre::Skeleton *creator)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Bone(Ogre::Bone *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Bone_createChild__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  unsigned short arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::Bone *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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(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","createChild", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(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 &","createChild", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChild", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createChild", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createChild", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  result = (Ogre::Bone *)(arg1)->createChild(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_createChild__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  unsigned short arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Bone *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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(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","createChild", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(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 &","createChild", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChild", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = (Ogre::Bone *)(arg1)->createChild(arg2,(Ogre::Vector3 const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_createChild__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Bone *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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","createChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(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","createChild", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Bone *)(arg1)->createChild(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Bone_createChild(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_Ogre__Bone, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Bone_createChild__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Bone, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(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_Bone_createChild__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Bone, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Bone_createChild__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Bone.createChild", 
    "    Ogre::Bone * Bone.createChild(unsigned short handle, Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::Bone * Bone.createChild(unsigned short handle, Ogre::Vector3 const &translate)\n"
    "    Ogre::Bone * Bone.createChild(unsigned short handle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_getHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone const *","getHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  result = (unsigned short)((Ogre::Bone const *)arg1)->getHandle();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_setBindingPose(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","setBindingPose", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  (arg1)->setBindingPose();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_setManuallyControlled(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","setManuallyControlled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setManuallyControlled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setManuallyControlled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_isManuallyControlled(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone const *","isManuallyControlled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  result = (bool)((Ogre::Bone const *)arg1)->isManuallyControlled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone__getOffsetTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  Ogre::Matrix4 *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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone const *","_getOffsetTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(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 &","_getOffsetTransform", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_getOffsetTransform", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::Bone const *)arg1)->_getOffsetTransform(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone__getBindingPoseInverseScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone const *","_getBindingPoseInverseScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Bone const *)arg1)->_getBindingPoseInverseScale();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone__getBindingPoseInversePosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone const *","_getBindingPoseInversePosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Bone const *)arg1)->_getBindingPoseInversePosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone__getBindingPoseInverseOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone const *","_getBindingPoseInverseOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Bone const *)arg1)->_getBindingPoseInverseOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_needUpdate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","needUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","needUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->needUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Bone_needUpdate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Bone *arg1 = (Ogre::Bone *) 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_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Bone *","needUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Bone * >(argp1);
  (arg1)->needUpdate();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Bone_needUpdate(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_Ogre__Bone, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Bone_needUpdate__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Bone, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Bone_needUpdate__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Bone.needUpdate", 
    "    void Bone.needUpdate(bool forceParentUpdate)\n"
    "    void Bone.needUpdate()\n");
  
  return Qnil;
}


swig_class SwigClassUTFString;

SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::UTFString *)new Ogre::UTFString();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *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__UTFString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::UTFString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::UTFString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::size_type arg1 ;
  Ogre::UTFString::code_point *arg2 = 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  Ogre::UTFString::code_point temp2 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","Ogre::UTFString", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::size_type >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","Ogre::UTFString", 2, argv[1] ));
  } 
  temp2 = static_cast< Ogre::UTFString::code_point >(val2);
  arg2 = &temp2;
  result = (Ogre::UTFString *)new Ogre::UTFString(arg1,(Ogre::UTFString::code_point const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point *arg1 = (Ogre::UTFString::code_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *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_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","Ogre::UTFString", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::code_point * >(argp1);
  result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString::code_point const *)arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point *arg1 = (Ogre::UTFString::code_point *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *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_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","Ogre::UTFString", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::code_point * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","Ogre::UTFString", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString::code_point const *)arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::UTFString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::UTFString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","Ogre::UTFString", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","Ogre::UTFString", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = (Ogre::UTFString *)new Ogre::UTFString((Ogre::UTFString const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_6(int argc, VALUE *argv, VALUE self) {
  std::wstring *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *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_std__wstring,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::wstring const &","Ogre::UTFString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::wstring const &","Ogre::UTFString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::wstring * >(argp1);
  result = (Ogre::UTFString *)new Ogre::UTFString((std::wstring const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_7(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","Ogre::UTFString", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  result = (Ogre::UTFString *)new Ogre::UTFString((char const *)arg1);
  DATA_PTR(self) = result;
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return self;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_8(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  res1 = SWIG_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char const *","Ogre::UTFString", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","Ogre::UTFString", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  result = (Ogre::UTFString *)new Ogre::UTFString((char const *)arg1,arg2);
  DATA_PTR(self) = result;
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return self;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_UTFString__SWIG_9(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::UTFString";
  Ogre::UTFString *result = 0 ;
  
  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 &","Ogre::UTFString", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Ogre::UTFString", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::UTFString *)new Ogre::UTFString((std::string const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UTFString(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_UTFString__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UTFString__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UTFString__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__wstring, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UTFString__SWIG_6(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_new_UTFString__SWIG_9(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_UTFString__SWIG_7(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_short, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UTFString__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UTFString__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_UTFString__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_UTFString__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UTFString.new", 
    "    UTFString.new()\n"
    "    UTFString.new(Ogre::UTFString const &copy)\n"
    "    UTFString.new(Ogre::UTFString::size_type length, Ogre::UTFString::code_point const &ch)\n"
    "    UTFString.new(Ogre::UTFString::code_point const *str)\n"
    "    UTFString.new(Ogre::UTFString::code_point const *str, Ogre::UTFString::size_type length)\n"
    "    UTFString.new(Ogre::UTFString const &str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type length)\n"
    "    UTFString.new(std::wstring const &wstr)\n"
    "    UTFString.new(char const *c_str)\n"
    "    UTFString.new(char const *c_str, Ogre::UTFString::size_type length)\n"
    "    UTFString.new(std::string const &str)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_UTFString(Ogre::UTFString *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::UTFString.size

  call-seq:
    size -> size_type

Size or Length of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_size(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->size();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.length

  call-seq:
    length -> size_type

Size or Length of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_length(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","length", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->length();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_length_Characters(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","length_Characters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->length_Characters();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.max_size

  call-seq:
    max_size -> size_type

Maximum size of elements allowed in the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_max_size(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","max_size", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->max_size();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.reserve

  call-seq:
    reserve(size)

Reserve memory in the UTFString for a number of elements.
*/
SWIGINTERN VALUE
_wrap_UTFString_reserve(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","reserve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","reserve", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  (arg1)->reserve(arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.resize

  call-seq:
    resize(num, val=0)
    resize(num)

Resize the size of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_resize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::code_point *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::code_point temp3 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","resize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","resize", 3, argv[1] ));
  } 
  temp3 = static_cast< Ogre::UTFString::code_point >(val3);
  arg3 = &temp3;
  (arg1)->resize(arg2,(Ogre::UTFString::code_point const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_resize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","resize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  (arg1)->resize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_resize(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_resize__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_resize__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "UTFString.resize", 
    "    void UTFString.resize(Ogre::UTFString::size_type num, Ogre::UTFString::code_point const &val)\n"
    "    void UTFString.resize(Ogre::UTFString::size_type num)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.empty

  call-seq:
    empty -> bool

Check if the UTFString is empty or not.
*/
SWIGINTERN VALUE
_wrap_UTFString_empty(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","empty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (bool)((Ogre::UTFString const *)arg1)->empty();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.c_str

  call-seq:
    c_str -> code_point

Convert class to a String representation.
*/
SWIGINTERN VALUE
_wrap_UTFString_c_str(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::code_point *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","c_str", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (Ogre::UTFString::code_point *)((Ogre::UTFString const *)arg1)->c_str();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_data(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::code_point *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","data", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (Ogre::UTFString::code_point *)((Ogre::UTFString const *)arg1)->data();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.capacity

  call-seq:
    capacity -> size_type

Reserved capacity of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_capacity(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","capacity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->capacity();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.clear

  call-seq:
    clear

Clear UTFString contents.
*/
SWIGINTERN VALUE
_wrap_UTFString_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.substr

  call-seq:
    substr(index, num=npos) -> UTFString
    substr(index) -> UTFString

Return a portion of the String.
*/
SWIGINTERN VALUE
_wrap_UTFString_substr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","substr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","substr", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","substr", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->substr(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_substr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","substr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","substr", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  result = ((Ogre::UTFString const *)arg1)->substr(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_substr(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_substr__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_substr__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "UTFString.substr", 
    "    Ogre::UTFString UTFString.substr(Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString UTFString.substr(Ogre::UTFString::size_type index)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.push_back

  call-seq:
    push_back(val)
    push_back(val)
    push_back(val)

Add an element at the end of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_push_back__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","push_back", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","push_back", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  (arg1)->push_back(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_push_back__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","push_back", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","push_back", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  (arg1)->push_back(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_push_back__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","push_back", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","push_back", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  (arg1)->push_back(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_push_back(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_push_back__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_push_back__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_push_back__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UTFString.push_back", 
    "    void UTFString.push_back(Ogre::UTFString::unicode_char val)\n"
    "    void UTFString.push_back(Ogre::UTFString::code_point val)\n"
    "    void UTFString.push_back(char val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_inString(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","inString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","inString", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = (bool)((Ogre::UTFString const *)arg1)->inString(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_asUTF8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::string *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","asUTF8", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (std::string *) &((Ogre::UTFString const *)arg1)->asUTF8();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_asUTF8_c_str(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","asUTF8_c_str", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (char *)((Ogre::UTFString const *)arg1)->asUTF8_c_str();
  vresult = SWIG_FromCharPtr((const char *)result);
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_asUTF32(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::utf32string *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","asUTF32", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (Ogre::UTFString::utf32string *) &((Ogre::UTFString const *)arg1)->asUTF32();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__basic_stringT_unsigned_int_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_asUTF32_c_str(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::unicode_char *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","asUTF32_c_str", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (Ogre::UTFString::unicode_char *)((Ogre::UTFString const *)arg1)->asUTF32_c_str();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_int, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_asWStr(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::wstring *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","asWStr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (std::wstring *) &((Ogre::UTFString const *)arg1)->asWStr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__wstring, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_asWStr_c_str(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  wchar_t *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","asWStr_c_str", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (wchar_t *)((Ogre::UTFString const *)arg1)->asWStr_c_str();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wchar_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.at

  call-seq:
    at(loc) -> code_point
    at(loc) -> code_point

Return element at a certain index.
*/
SWIGINTERN VALUE
_wrap_UTFString_at__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::code_point *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","at", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","at", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  result = (Ogre::UTFString::code_point *) &(arg1)->at(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_short, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_at__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::code_point *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","at", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","at", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  result = (Ogre::UTFString::code_point *) &((Ogre::UTFString const *)arg1)->at(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_at(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_at__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_at__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UTFString.at", 
    "    Ogre::UTFString::code_point const & UTFString.at(Ogre::UTFString::size_type loc)\n"
    "    Ogre::UTFString::code_point const & UTFString.at(Ogre::UTFString::size_type loc)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_getChar(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::unicode_char 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","getChar", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","getChar", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  result = (Ogre::UTFString::unicode_char)((Ogre::UTFString const *)arg1)->getChar(arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_setChar(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::unicode_char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","setChar", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","setChar", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","setChar", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::unicode_char >(val3);
  result = (int)(arg1)->setChar(arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.begin

  call-seq:
    begin -> iterator
    begin -> const_iterator

Return an iterator to the beginning of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_begin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (arg1)->begin();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::iterator(static_cast< const Ogre::UTFString::iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___fwd_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_begin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::const_iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->begin();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::const_iterator(static_cast< const Ogre::UTFString::const_iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_begin(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_begin__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_begin__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "UTFString.begin", 
    "    Ogre::UTFString::const_iterator UTFString.begin()\n"
    "    Ogre::UTFString::const_iterator UTFString.begin()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.end

  call-seq:
    end -> iterator
    end -> const_iterator

Return an iterator to past the end of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_end__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (arg1)->end();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::iterator(static_cast< const Ogre::UTFString::iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___fwd_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_end__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::const_iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->end();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::const_iterator(static_cast< const Ogre::UTFString::const_iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_end(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_end__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_end__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "UTFString.end", 
    "    Ogre::UTFString::const_iterator UTFString.end()\n"
    "    Ogre::UTFString::const_iterator UTFString.end()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.rbegin

  call-seq:
    rbegin -> reverse_iterator
    rbegin -> const_reverse_iterator

Return a reverse iterator to the beginning (the end) of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_rbegin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::reverse_iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","rbegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (arg1)->rbegin();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::reverse_iterator(static_cast< const Ogre::UTFString::reverse_iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___rev_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rbegin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::const_reverse_iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rbegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->rbegin();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::const_reverse_iterator(static_cast< const Ogre::UTFString::const_reverse_iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_rbegin(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_rbegin__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_rbegin__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "UTFString.rbegin", 
    "    Ogre::UTFString::const_reverse_iterator UTFString.rbegin()\n"
    "    Ogre::UTFString::const_reverse_iterator UTFString.rbegin()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.rend

  call-seq:
    rend -> reverse_iterator
    rend -> const_reverse_iterator

Return a reverse iterator to past the end (past the beginning) of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_rend__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::reverse_iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","rend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (arg1)->rend();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::reverse_iterator(static_cast< const Ogre::UTFString::reverse_iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___rev_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rend__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::const_reverse_iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = ((Ogre::UTFString const *)arg1)->rend();
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::const_reverse_iterator(static_cast< const Ogre::UTFString::const_reverse_iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_rend(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_rend__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_rend__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "UTFString.rend", 
    "    Ogre::UTFString::const_reverse_iterator UTFString.rend()\n"
    "    Ogre::UTFString::const_reverse_iterator UTFString.rend()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.assign

  call-seq:
    assign(start, end) -> UTFString
    assign(str) -> UTFString
    assign(str) -> UTFString
    assign(str, num) -> UTFString
    assign(str, index, len) -> UTFString
    assign(num, ch) -> UTFString
    assign(wstr) -> UTFString
    assign(str) -> UTFString
    assign(c_str) -> UTFString
    assign(c_str, num) -> UTFString

Assign a new UTFString or portion of it.
*/
SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","assign", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","assign", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","assign", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","assign", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp3));
    }
  }
  result = (Ogre::UTFString *) &(arg1)->assign(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","assign", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","assign", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point *arg2 = (Ogre::UTFString::code_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","assign", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString::code_point const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point *arg2 = (Ogre::UTFString::code_point *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","assign", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","assign", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString::code_point const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","assign", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","assign", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","assign", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","assign", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = (Ogre::UTFString *) &(arg1)->assign((Ogre::UTFString const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::code_point *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::code_point temp3 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","assign", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","assign", 3, argv[1] ));
  } 
  temp3 = static_cast< Ogre::UTFString::code_point >(val3);
  arg3 = &temp3;
  result = (Ogre::UTFString *) &(arg1)->assign(arg2,(Ogre::UTFString::code_point const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  std::wstring *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__wstring,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::wstring const &","assign", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::wstring const &","assign", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< std::wstring * >(argp2);
  result = (Ogre::UTFString *) &(arg1)->assign((std::wstring const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  std::string *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(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 &","assign", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","assign", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::UTFString *) &(arg1)->assign((std::string const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char *arg2 = (char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","assign", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (Ogre::UTFString *) &(arg1)->assign((char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_assign__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char *arg2 = (char *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","assign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","assign", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","assign", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = (Ogre::UTFString *) &(arg1)->assign((char const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_assign(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_assign__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_assign__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_std__wstring, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_assign__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_UTFString_assign__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_assign__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UTFString_assign__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_assign__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_assign__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_assign__SWIG_9(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_assign__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.assign", 
    "    Ogre::UTFString & UTFString.assign(Ogre::UTFString::iterator start, Ogre::UTFString::iterator end)\n"
    "    Ogre::UTFString & UTFString.assign(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString & UTFString.assign(Ogre::UTFString::code_point const *str)\n"
    "    Ogre::UTFString & UTFString.assign(Ogre::UTFString::code_point const *str, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString & UTFString.assign(Ogre::UTFString const &str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type len)\n"
    "    Ogre::UTFString & UTFString.assign(Ogre::UTFString::size_type num, Ogre::UTFString::code_point const &ch)\n"
    "    Ogre::UTFString & UTFString.assign(std::wstring const &wstr)\n"
    "    Ogre::UTFString & UTFString.assign(std::string const &str)\n"
    "    Ogre::UTFString & UTFString.assign(char const *c_str)\n"
    "    Ogre::UTFString & UTFString.assign(char const *c_str, Ogre::UTFString::size_type num)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","append", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","append", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point *arg2 = (Ogre::UTFString::code_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","append", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString::code_point const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","append", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","append", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","append", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","append", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point *arg2 = (Ogre::UTFString::code_point *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","append", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","append", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = (Ogre::UTFString *) &(arg1)->append((Ogre::UTFString::code_point const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::code_point arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","append", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","append", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::code_point >(val3);
  result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","append", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","append", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","append", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","append", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp3));
    }
  }
  result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char *arg2 = (char *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","append", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","append", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = (Ogre::UTFString *) &(arg1)->append((char const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","append", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","append", 3, argv[1] ));
  } 
  arg3 = static_cast< char >(val3);
  result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_append__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::unicode_char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","append", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","append", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","append", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::unicode_char >(val3);
  result = (Ogre::UTFString *) &(arg1)->append(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_append(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_append__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_append__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_append__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UTFString_append__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_append__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_append__SWIG_8(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_append__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_append__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_append__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.append", 
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString::code_point const *str)\n"
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString const &str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type len)\n"
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString::code_point const *str, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString::size_type num, Ogre::UTFString::code_point ch)\n"
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString::iterator start, Ogre::UTFString::iterator end)\n"
    "    Ogre::UTFString & UTFString.append(char const *c_str, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString::size_type num, char ch)\n"
    "    Ogre::UTFString & UTFString.append(Ogre::UTFString::size_type num, Ogre::UTFString::unicode_char ch)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.insert

  call-seq:
    insert(i, ch) -> iterator
    insert(index, str) -> UTFString
    insert(index, str) -> UTFString
    insert(index1, str, index2, num) -> UTFString
    insert(i, start, end)
    insert(index, str, num) -> UTFString
    insert(index, c_str, num) -> UTFString
    insert(index, num, ch) -> UTFString
    insert(index, num, ch) -> UTFString
    insert(index, num, ch) -> UTFString
    insert(i, num, ch)
    insert(i, num, ch)
    insert(i, num, ch)

Insert one or more new elements in the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::code_point *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::code_point temp3 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","insert", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","insert", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","insert", 3, argv[1] ));
  } 
  temp3 = static_cast< Ogre::UTFString::code_point >(val3);
  arg3 = &temp3;
  result = (arg1)->insert(arg2,(Ogre::UTFString::code_point const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::iterator(static_cast< const Ogre::UTFString::iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___fwd_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString const &","insert", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","insert", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::UTFString * >(argp3);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::code_point *arg3 = (Ogre::UTFString::code_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","insert", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::UTFString::code_point * >(argp3);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString::code_point const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString *arg3 = 0 ;
  Ogre::UTFString::size_type arg4 ;
  Ogre::UTFString::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString const &","insert", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","insert", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::UTFString * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::size_type >(val5);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::iterator arg3 ;
  Ogre::UTFString::iterator arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","insert", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","insert", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","insert", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","insert", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp3));
    }
  }
  {
    res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","insert", 4, argv[2] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","insert", 4, argv[2]));
    } else {
      arg4 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp4));
    }
  }
  (arg1)->insert(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::code_point *arg3 = (Ogre::UTFString::code_point *) 0 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","insert", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::UTFString::code_point * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,(Ogre::UTFString::code_point const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  char *arg3 = (char *) 0 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[1], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","insert", 3, argv[1] ));
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,(char const *)arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::code_point arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","insert", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::code_point >(val4);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  char arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_char(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","insert", 4, argv[2] ));
  } 
  arg4 = static_cast< char >(val4);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::unicode_char arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","insert", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::unicode_char >(val4);
  result = (Ogre::UTFString *) &(arg1)->insert(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::code_point *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::code_point temp4 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","insert", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","insert", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","insert", 4, argv[2] ));
  } 
  temp4 = static_cast< Ogre::UTFString::code_point >(val4);
  arg4 = &temp4;
  (arg1)->insert(arg2,arg3,(Ogre::UTFString::code_point const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::size_type arg3 ;
  char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  char temp4 ;
  char val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","insert", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","insert", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_char(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","insert", 4, argv[2] ));
  } 
  temp4 = static_cast< char >(val4);
  arg4 = &temp4;
  (arg1)->insert(arg2,arg3,(char const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_insert__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::unicode_char *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::unicode_char temp4 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","insert", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","insert", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","insert", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","insert", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","insert", 4, argv[2] ));
  } 
  temp4 = static_cast< Ogre::UTFString::unicode_char >(val4);
  arg4 = &temp4;
  (arg1)->insert(arg2,arg3,(Ogre::UTFString::unicode_char const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_insert(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_insert__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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__UTFString, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UTFString_insert__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UTFString_insert__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UTFString_insert__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_insert__SWIG_10(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_UTFString_insert__SWIG_12(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_insert__SWIG_11(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_unsigned_short, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_insert__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_insert__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(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_UTFString_insert__SWIG_9(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_insert__SWIG_8(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_AsCharPtrAndSize(argv[2], 0, NULL, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_insert__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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__UTFString, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UTFString_insert__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "UTFString.insert", 
    "    void UTFString.insert(Ogre::UTFString::iterator i, Ogre::UTFString::code_point const &ch)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index, Ogre::UTFString const &str)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index, Ogre::UTFString::code_point const *str)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index1, Ogre::UTFString const &str, Ogre::UTFString::size_type index2, Ogre::UTFString::size_type num)\n"
    "    void UTFString.insert(Ogre::UTFString::iterator i, Ogre::UTFString::iterator start, Ogre::UTFString::iterator end)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index, Ogre::UTFString::code_point const *str, Ogre::UTFString::size_type num)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index, char const *c_str, Ogre::UTFString::size_type num)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index, Ogre::UTFString::size_type num, Ogre::UTFString::code_point ch)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index, Ogre::UTFString::size_type num, char ch)\n"
    "    void UTFString.insert(Ogre::UTFString::size_type index, Ogre::UTFString::size_type num, Ogre::UTFString::unicode_char ch)\n"
    "    void UTFString.insert(Ogre::UTFString::iterator i, Ogre::UTFString::size_type num, Ogre::UTFString::code_point const &ch)\n"
    "    void UTFString.insert(Ogre::UTFString::iterator i, Ogre::UTFString::size_type num, char const &ch)\n"
    "    void UTFString.insert(Ogre::UTFString::iterator i, Ogre::UTFString::size_type num, Ogre::UTFString::unicode_char const &ch)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.erase

  call-seq:
    erase(loc) -> iterator
    erase(start, end) -> iterator
    erase(index=0, num=npos) -> UTFString
    erase(index=0) -> UTFString
    erase -> UTFString

Delete a portion of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_erase__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","erase", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","erase", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","erase", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  result = (arg1)->erase(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::iterator(static_cast< const Ogre::UTFString::iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___fwd_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_erase__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::iterator arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::UTFString::iterator 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","erase", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","erase", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","erase", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","erase", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","erase", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp3));
    }
  }
  result = (arg1)->erase(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString::iterator(static_cast< const Ogre::UTFString::iterator& >(result))), SWIGTYPE_p_Ogre__UTFString___fwd_iterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_erase__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","erase", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","erase", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","erase", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = (Ogre::UTFString *) &(arg1)->erase(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_erase__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","erase", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","erase", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  result = (Ogre::UTFString *) &(arg1)->erase(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_erase__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","erase", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  result = (Ogre::UTFString *) &(arg1)->erase();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_erase(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString_erase__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_erase__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_erase__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_UTFString_erase__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_erase__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "UTFString.erase", 
    "    Ogre::UTFString & UTFString.erase(Ogre::UTFString::iterator loc)\n"
    "    Ogre::UTFString & UTFString.erase(Ogre::UTFString::iterator start, Ogre::UTFString::iterator end)\n"
    "    Ogre::UTFString & UTFString.erase(Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString & UTFString.erase(Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString & UTFString.erase()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.replace

  call-seq:
    replace(index1, num1, str) -> UTFString
    replace(index1, num1, str, num2) -> UTFString
    replace(index1, num1, str, index2, num2) -> UTFString
    replace(start, end, str, num=npos) -> UTFString
    replace(start, end, str) -> UTFString
    replace(index, num1, num2, ch) -> UTFString
    replace(start, end, num, ch) -> UTFString

Replace all or a portion of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_replace__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","replace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString const &","replace", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","replace", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString * >(argp4);
  result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_replace__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString *arg4 = 0 ;
  Ogre::UTFString::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","replace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString const &","replace", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","replace", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString * >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::size_type >(val5);
  result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_replace__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString *arg4 = 0 ;
  Ogre::UTFString::size_type arg5 ;
  Ogre::UTFString::size_type arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Ogre::UTFString *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","replace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString const &","replace", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","replace", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString * >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::size_type >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::UTFString::size_type >(val6);
  result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_replace__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::iterator arg3 ;
  Ogre::UTFString *arg4 = 0 ;
  Ogre::UTFString::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","replace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","replace", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","replace", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","replace", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","replace", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp3));
    }
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString const &","replace", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","replace", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString * >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::size_type >(val5);
  result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_replace__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::iterator arg3 ;
  Ogre::UTFString *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","replace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","replace", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","replace", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","replace", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","replace", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp3));
    }
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString const &","replace", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","replace", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString * >(argp4);
  result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,(Ogre::UTFString const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_replace__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  Ogre::UTFString::code_point arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","replace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","replace", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::code_point >(val5);
  result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_replace__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::iterator arg2 ;
  Ogre::UTFString::iterator arg3 ;
  Ogre::UTFString::size_type arg4 ;
  Ogre::UTFString::code_point arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString *","replace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","replace", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","replace", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp2));
    }
  }
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__UTFString___fwd_iterator,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::UTFString::iterator","replace", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::iterator","replace", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::UTFString::iterator * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","replace", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","replace", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::code_point >(val5);
  result = (Ogre::UTFString *) &(arg1)->replace(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_replace(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UTFString_replace__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UTFString_replace__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UTFString_replace__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__UTFString___fwd_iterator, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UTFString_replace__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UTFString_replace__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UTFString_replace__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_UTFString_replace__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "UTFString.replace", 
    "    Ogre::UTFString & UTFString.replace(Ogre::UTFString::size_type index1, Ogre::UTFString::size_type num1, Ogre::UTFString const &str)\n"
    "    Ogre::UTFString & UTFString.replace(Ogre::UTFString::size_type index1, Ogre::UTFString::size_type num1, Ogre::UTFString const &str, Ogre::UTFString::size_type num2)\n"
    "    Ogre::UTFString & UTFString.replace(Ogre::UTFString::size_type index1, Ogre::UTFString::size_type num1, Ogre::UTFString const &str, Ogre::UTFString::size_type index2, Ogre::UTFString::size_type num2)\n"
    "    Ogre::UTFString & UTFString.replace(Ogre::UTFString::iterator start, Ogre::UTFString::iterator end, Ogre::UTFString const &str, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString & UTFString.replace(Ogre::UTFString::iterator start, Ogre::UTFString::iterator end, Ogre::UTFString const &str)\n"
    "    Ogre::UTFString & UTFString.replace(Ogre::UTFString::size_type index, Ogre::UTFString::size_type num1, Ogre::UTFString::size_type num2, Ogre::UTFString::code_point ch)\n"
    "    Ogre::UTFString & UTFString.replace(Ogre::UTFString::iterator start, Ogre::UTFString::iterator end, Ogre::UTFString::size_type num, Ogre::UTFString::code_point ch)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_compare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","compare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","compare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","compare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (int)((Ogre::UTFString const *)arg1)->compare((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_compare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point *arg2 = (Ogre::UTFString::code_point *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","compare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","compare", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  result = (int)((Ogre::UTFString const *)arg1)->compare((Ogre::UTFString::code_point const *)arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_compare__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  int 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","compare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString const &","compare", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","compare", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString * >(argp4);
  result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(Ogre::UTFString const &)*arg4);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_compare__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString *arg4 = 0 ;
  Ogre::UTFString::size_type arg5 ;
  Ogre::UTFString::size_type arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  int result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","compare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString const &","compare", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","compare", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString * >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::size_type >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::UTFString::size_type >(val6);
  result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(Ogre::UTFString const &)*arg4,arg5,arg6);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_compare__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::code_point *arg4 = (Ogre::UTFString::code_point *) 0 ;
  Ogre::UTFString::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int result;
  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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","compare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","compare", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::UTFString::code_point * >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::size_type >(val5);
  result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(Ogre::UTFString::code_point const *)arg4,arg5);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_compare__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::size_type arg2 ;
  Ogre::UTFString::size_type arg3 ;
  char *arg4 = (char *) 0 ;
  Ogre::UTFString::size_type arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int result;
  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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","compare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::size_type >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","compare", 4, argv[2] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","compare", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::UTFString::size_type >(val5);
  result = (int)((Ogre::UTFString const *)arg1)->compare(arg2,arg3,(char const *)arg4,arg5);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_compare(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_compare__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_compare__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_UTFString_compare__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_short, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UTFString_compare__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_UTFString_compare__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_UTFString_compare__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "UTFString.compare", 
    "    int UTFString.compare(Ogre::UTFString const &str)\n"
    "    int UTFString.compare(Ogre::UTFString::code_point const *str)\n"
    "    int UTFString.compare(Ogre::UTFString::size_type index, Ogre::UTFString::size_type length, Ogre::UTFString const &str)\n"
    "    int UTFString.compare(Ogre::UTFString::size_type index, Ogre::UTFString::size_type length, Ogre::UTFString const &str, Ogre::UTFString::size_type index2, Ogre::UTFString::size_type length2)\n"
    "    int UTFString.compare(Ogre::UTFString::size_type index, Ogre::UTFString::size_type length, Ogre::UTFString::code_point const *str, Ogre::UTFString::size_type length2)\n"
    "    int UTFString.compare(Ogre::UTFString::size_type index, Ogre::UTFString::size_type length, char const *c_str, Ogre::UTFString::size_type length2)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.find

  call-seq:
    find(str, index=0) -> size_type
    find(str) -> size_type
    find(cp_str, index, length) -> size_type
    find(c_str, index, length) -> size_type
    find(ch, index=0) -> size_type
    find(ch) -> size_type
    find(ch, index=0) -> size_type
    find(ch) -> size_type
    find(ch, index=0) -> size_type
    find(ch) -> size_type

Find an element in the class.
*/
SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find((Ogre::UTFString const &)*arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = ((Ogre::UTFString const *)arg1)->find((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point *arg2 = (Ogre::UTFString::code_point *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","find", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->find((Ogre::UTFString::code_point const *)arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char *arg2 = (char *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","find", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->find((char const *)arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  result = ((Ogre::UTFString const *)arg1)->find(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_find(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_find__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find__SWIG_9(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find__SWIG_8(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_find__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_find__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.find", 
    "    Ogre::UTFString::size_type UTFString.find(Ogre::UTFString const &str, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString::size_type UTFString.find(Ogre::UTFString::code_point const *cp_str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type length)\n"
    "    Ogre::UTFString::size_type UTFString.find(char const *c_str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type length)\n"
    "    Ogre::UTFString::size_type UTFString.find(char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find(char ch)\n"
    "    Ogre::UTFString::size_type UTFString.find(Ogre::UTFString::code_point ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find(Ogre::UTFString::code_point ch)\n"
    "    Ogre::UTFString::size_type UTFString.find(Ogre::UTFString::unicode_char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find(Ogre::UTFString::unicode_char ch)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.rfind

  call-seq:
    rfind(str, index=0) -> size_type
    rfind(str) -> size_type
    rfind(cp_str, index, num) -> size_type
    rfind(c_str, index, num) -> size_type
    rfind(ch, index=0) -> size_type
    rfind(ch) -> size_type
    rfind(ch, index) -> size_type
    rfind(ch, index=0) -> size_type
    rfind(ch) -> size_type

Find an element in reverse usually starting from the end of the UTFString.
*/
SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","rfind", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","rfind", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->rfind((Ogre::UTFString const &)*arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","rfind", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","rfind", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = ((Ogre::UTFString const *)arg1)->rfind((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point *arg2 = (Ogre::UTFString::code_point *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const *","rfind", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->rfind((Ogre::UTFString::code_point const *)arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char *arg2 = (char *) 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","rfind", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->rfind((char const *)arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","rfind", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->rfind(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","rfind", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  result = ((Ogre::UTFString const *)arg1)->rfind(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","rfind", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->rfind(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","rfind", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","rfind", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->rfind(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_rfind__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","rfind", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","rfind", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = ((Ogre::UTFString const *)arg1)->rfind(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_rfind(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_rfind__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_rfind__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_rfind__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_rfind__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_rfind__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_rfind__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_rfind__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_short, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_rfind__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_rfind__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.rfind", 
    "    Ogre::UTFString::size_type UTFString.rfind(Ogre::UTFString const &str, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(Ogre::UTFString::code_point const *cp_str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(char const *c_str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(char ch)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(Ogre::UTFString::code_point ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(Ogre::UTFString::unicode_char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.rfind(Ogre::UTFString::unicode_char ch)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_first_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_first_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_of", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->find_first_of((Ogre::UTFString const &)*arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_first_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_first_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_of((Ogre::UTFString const &)*arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_first_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_first_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = ((Ogre::UTFString const *)arg1)->find_first_of((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_first_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_first_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_first_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_first_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_first_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_of__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_first_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_first_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_find_first_of(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_find_first_of__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_first_of__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_first_of__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_first_of__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_of__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_of__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_of__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_of__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_find_first_of__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.find_first_of", 
    "    Ogre::UTFString::size_type UTFString.find_first_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(Ogre::UTFString::code_point ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(Ogre::UTFString::code_point ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(char ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(Ogre::UTFString::unicode_char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_of(Ogre::UTFString::unicode_char ch)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_first_not_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_first_not_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_not_of", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of((Ogre::UTFString const &)*arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_first_not_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_first_not_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of((Ogre::UTFString const &)*arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_first_not_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_first_not_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_first_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_first_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_first_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_first_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_first_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_first_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_first_not_of__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_first_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_first_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_first_not_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_find_first_not_of(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_find_first_not_of__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_first_not_of__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_first_not_of__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_first_not_of__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_not_of__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_not_of__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_not_of__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_first_not_of__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_find_first_not_of__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.find_first_not_of", 
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(Ogre::UTFString::code_point ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(Ogre::UTFString::code_point ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(char ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(Ogre::UTFString::unicode_char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_first_not_of(Ogre::UTFString::unicode_char ch)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_last_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_last_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_of", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->find_last_of((Ogre::UTFString const &)*arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_last_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_last_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_of((Ogre::UTFString const &)*arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_last_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_last_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = ((Ogre::UTFString const *)arg1)->find_last_of((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_last_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_last_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_last_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_last_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_last_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_of__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_last_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_last_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_find_last_of(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_find_last_of__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_last_of__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_last_of__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_last_of__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_of__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_of__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_of__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_of__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_find_last_of__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.find_last_of", 
    "    Ogre::UTFString::size_type UTFString.find_last_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(Ogre::UTFString::code_point ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(Ogre::UTFString::code_point ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(char ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(Ogre::UTFString::unicode_char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_of(Ogre::UTFString::unicode_char ch)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  Ogre::UTFString::size_type arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_last_not_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_last_not_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_not_of", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::UTFString::size_type >(val4);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of((Ogre::UTFString const &)*arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_last_not_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_last_not_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of((Ogre::UTFString const &)*arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","find_last_not_of", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","find_last_not_of", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_last_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::code_point arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","find_last_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_last_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","find_last_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  Ogre::UTFString::size_type arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_last_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::UTFString::size_type","find_last_not_of", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::UTFString::size_type >(val3);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString_find_last_not_of__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString::size_type 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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","find_last_not_of", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","find_last_not_of", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = ((Ogre::UTFString const *)arg1)->find_last_not_of(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString_find_last_not_of(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_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_UTFString_find_last_not_of__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_last_not_of__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_last_not_of__SWIG_8(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UTFString_find_last_not_of__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_not_of__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_not_of__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_not_of__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_UTFString_find_last_not_of__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_UTFString_find_last_not_of__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "UTFString.find_last_not_of", 
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index, Ogre::UTFString::size_type num)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(Ogre::UTFString const &str, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(Ogre::UTFString const &str)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(Ogre::UTFString::code_point ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(Ogre::UTFString::code_point ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(char ch)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(Ogre::UTFString::unicode_char ch, Ogre::UTFString::size_type index)\n"
    "    Ogre::UTFString::size_type UTFString.find_last_not_of(Ogre::UTFString::unicode_char ch)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.<

  call-seq:
    <(right) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_UTFString___lt__(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (bool)((Ogre::UTFString const *)arg1)->operator <((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.<=

  call-seq:
    <=(right) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_UTFString___le__(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","operator <=", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","operator <=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","operator <=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (bool)((Ogre::UTFString const *)arg1)->operator <=((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.>

  call-seq:
    >(right) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap_UTFString___gt__(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","operator >", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","operator >", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","operator >", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (bool)((Ogre::UTFString const *)arg1)->operator >((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.>=

  call-seq:
    >=(right) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap_UTFString___ge__(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","operator >=", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","operator >=", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","operator >=", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (bool)((Ogre::UTFString const *)arg1)->operator >=((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::UTFString.==

  call-seq:
    ==(right) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_UTFString___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = (Ogre::UTFString *) 0 ;
  Ogre::UTFString *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_Ogre__UTFString, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (bool)((Ogre::UTFString const *)arg1)->operator ==((Ogre::UTFString const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf16_independent_char(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","Ogre::UTFString::_utf16_independent_char", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::code_point >(val1);
  result = (bool)Ogre::UTFString::_utf16_independent_char(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf16_surrogate_lead(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","Ogre::UTFString::_utf16_surrogate_lead", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::code_point >(val1);
  result = (bool)Ogre::UTFString::_utf16_surrogate_lead(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf16_surrogate_follow(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","Ogre::UTFString::_utf16_surrogate_follow", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::code_point >(val1);
  result = (bool)Ogre::UTFString::_utf16_surrogate_follow(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf16_char_length__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","Ogre::UTFString::_utf16_char_length", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::code_point >(val1);
  result = Ogre::UTFString::_utf16_char_length(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf16_char_length__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::unicode_char arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","Ogre::UTFString::_utf16_char_length", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::unicode_char >(val1);
  result = Ogre::UTFString::_utf16_char_length(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString__utf16_char_length(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_UTFString__utf16_char_length__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_UTFString__utf16_char_length__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UTFString._utf16_char_length", 
    "    size_t UTFString._utf16_char_length(Ogre::UTFString::code_point cp)\n"
    "    size_t UTFString._utf16_char_length(Ogre::UTFString::unicode_char uc)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf16_to_utf32(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point *arg1 ;
  Ogre::UTFString::unicode_char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t 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_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point const [2]","Ogre::UTFString::_utf16_to_utf32", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< Ogre::UTFString::code_point * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char &","Ogre::UTFString::_utf16_to_utf32", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::unicode_char &","Ogre::UTFString::_utf16_to_utf32", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::unicode_char * >(argp2);
  result = Ogre::UTFString::_utf16_to_utf32((unsigned short const (*))arg1,*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf32_to_utf16(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::unicode_char *arg1 = 0 ;
  Ogre::UTFString::code_point *arg2 ;
  Ogre::UTFString::unicode_char temp1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t 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_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","Ogre::UTFString::_utf32_to_utf16", 1, argv[0] ));
  } 
  temp1 = static_cast< Ogre::UTFString::unicode_char >(val1);
  arg1 = &temp1;
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point [2]","Ogre::UTFString::_utf32_to_utf16", 2, argv[1] )); 
  } 
  arg2 = reinterpret_cast< Ogre::UTFString::code_point * >(argp2);
  result = Ogre::UTFString::_utf32_to_utf16((unsigned int const &)*arg1,arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf8_start_char(int argc, VALUE *argv, VALUE self) {
  unsigned char arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned char","Ogre::UTFString::_utf8_start_char", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned char >(val1);
  result = (bool)Ogre::UTFString::_utf8_start_char(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf8_char_length__SWIG_0(int argc, VALUE *argv, VALUE self) {
  unsigned char arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned char","Ogre::UTFString::_utf8_char_length", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned char >(val1);
  result = Ogre::UTFString::_utf8_char_length(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf8_char_length__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::unicode_char arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","Ogre::UTFString::_utf8_char_length", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::unicode_char >(val1);
  result = Ogre::UTFString::_utf8_char_length(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString__utf8_char_length(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_UTFString__utf8_char_length__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_UTFString__utf8_char_length__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UTFString._utf8_char_length", 
    "    size_t UTFString._utf8_char_length(unsigned char cp)\n"
    "    size_t UTFString._utf8_char_length(Ogre::UTFString::unicode_char uc)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf8_to_utf32(int argc, VALUE *argv, VALUE self) {
  unsigned char *arg1 ;
  Ogre::UTFString::unicode_char *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t 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_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "unsigned char const [6]","Ogre::UTFString::_utf8_to_utf32", 1, argv[0] )); 
  } 
  arg1 = reinterpret_cast< unsigned char * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char &","Ogre::UTFString::_utf8_to_utf32", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::unicode_char &","Ogre::UTFString::_utf8_to_utf32", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::unicode_char * >(argp2);
  result = Ogre::UTFString::_utf8_to_utf32((unsigned char const (*))arg1,*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__utf32_to_utf8(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::unicode_char *arg1 = 0 ;
  unsigned char *arg2 ;
  Ogre::UTFString::unicode_char temp1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t 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_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","Ogre::UTFString::_utf32_to_utf8", 1, argv[0] ));
  } 
  temp1 = static_cast< Ogre::UTFString::unicode_char >(val1);
  arg1 = &temp1;
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char [6]","Ogre::UTFString::_utf32_to_utf8", 2, argv[1] )); 
  } 
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  result = Ogre::UTFString::_utf32_to_utf8((unsigned int const &)*arg1,arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__verifyUTF8__SWIG_0(int argc, VALUE *argv, VALUE self) {
  unsigned char *arg1 = (unsigned char *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UTFString::size_type 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_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "unsigned char const *","Ogre::UTFString::_verifyUTF8", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< unsigned char * >(argp1);
  result = Ogre::UTFString::_verifyUTF8((unsigned char const *)arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UTFString__verifyUTF8__SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::string *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::UTFString::size_type 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 &","Ogre::UTFString::_verifyUTF8", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::string const &","Ogre::UTFString::_verifyUTF8", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::UTFString::_verifyUTF8((std::string const &)*arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_UTFString__verifyUTF8(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UTFString__verifyUTF8__SWIG_0(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_UTFString__verifyUTF8__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "UTFString._verifyUTF8", 
    "    Ogre::UTFString::size_type UTFString._verifyUTF8(unsigned char const *c_str)\n"
    "    Ogre::UTFString::size_type UTFString._verifyUTF8(std::string const &str)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.+

  call-seq:
    +(s1, s2) -> UTFString
    +(s1, c) -> UTFString
    +(s1, c) -> UTFString
    +(s1, c) -> UTFString
    +(c, s2) -> UTFString
    +(c, s2) -> UTFString
    +(c, s2) -> UTFString

Add operator.
*/
SWIGINTERN VALUE
_wrap___add____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString 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__UTFString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = Ogre::operator +((Ogre::UTFString const &)*arg1,(Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___add____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = 0 ;
  Ogre::UTFString::code_point arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString 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__UTFString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","Ogre::operator +", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::UTFString::code_point >(val2);
  result = Ogre::operator +((Ogre::UTFString const &)*arg1,arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___add____SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = 0 ;
  Ogre::UTFString::unicode_char arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString 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__UTFString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","Ogre::operator +", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::UTFString::unicode_char >(val2);
  result = Ogre::operator +((Ogre::UTFString const &)*arg1,arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___add____SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString *arg1 = 0 ;
  char arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  char val2 ;
  int ecode2 = 0 ;
  Ogre::UTFString 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__UTFString,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString * >(argp1);
  ecode2 = SWIG_AsVal_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "char","Ogre::operator +", 2, argv[1] ));
  } 
  arg2 = static_cast< char >(val2);
  result = Ogre::operator +((Ogre::UTFString const &)*arg1,arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___add____SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::code_point arg1 ;
  Ogre::UTFString *arg2 = 0 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString 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_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::code_point","Ogre::operator +", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::code_point >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = Ogre::operator +(arg1,(Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___add____SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::unicode_char arg1 ;
  Ogre::UTFString *arg2 = 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString 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_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::UTFString::unicode_char","Ogre::operator +", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::UTFString::unicode_char >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = Ogre::operator +(arg1,(Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___add____SWIG_6(int argc, VALUE *argv, VALUE self) {
  char arg1 ;
  Ogre::UTFString *arg2 = 0 ;
  char val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString 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_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "char","Ogre::operator +", 1, argv[0] ));
  } 
  arg1 = static_cast< char >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator +", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = Ogre::operator +(arg1,(Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::UTFString(static_cast< const Ogre::UTFString& >(result))), SWIGTYPE_p_Ogre__UTFString, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___add__(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__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___add____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___add____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___add____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap___add____SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_short(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___add____SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___add____SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___add____SWIG_6(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__add__", 
    "    Ogre::UTFString __add__(Ogre::UTFString const &s1, Ogre::UTFString const &s2)\n"
    "    Ogre::UTFString __add__(Ogre::UTFString const &s1, Ogre::UTFString::code_point c)\n"
    "    Ogre::UTFString __add__(Ogre::UTFString const &s1, Ogre::UTFString::unicode_char c)\n"
    "    Ogre::UTFString __add__(Ogre::UTFString const &s1, char c)\n"
    "    Ogre::UTFString __add__(Ogre::UTFString::code_point c, Ogre::UTFString const &s2)\n"
    "    Ogre::UTFString __add__(Ogre::UTFString::unicode_char c, Ogre::UTFString const &s2)\n"
    "    Ogre::UTFString __add__(char c, Ogre::UTFString const &s2)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.-

  call-seq:
    -(left, right) -> size_type
    -(left, right) -> size_type

Substraction operator.
*/
SWIGINTERN VALUE
_wrap___sub____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_fwd_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_fwd_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator -", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator -", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator -", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator -", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp2);
  result = Ogre::operator -((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.==

  call-seq:
    ==(left, right) -> bool
    ==(left, right) -> bool
    ==(lhs, rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap___eq____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_fwd_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_fwd_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator ==", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator ==", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator ==", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator ==", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp2);
  result = (bool)Ogre::operator ==((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.<

  call-seq:
    <(left, right) -> bool
    <(left, right) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap___lt____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_fwd_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_fwd_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp2);
  result = (bool)Ogre::operator <((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.<=

  call-seq:
    <=(left, right) -> bool
    <=(left, right) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___le____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_fwd_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_fwd_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator <=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp2);
  result = (bool)Ogre::operator <=((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.>

  call-seq:
    >(left, right) -> bool
    >(left, right) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap___gt____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_fwd_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_fwd_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp2);
  result = (bool)Ogre::operator >((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.>=

  call-seq:
    >=(left, right) -> bool
    >=(left, right) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___ge____SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_fwd_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_fwd_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_fwd_iterator const &","Ogre::operator >=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_fwd_iterator * >(argp2);
  result = (bool)Ogre::operator >=((Ogre::UTFString::_const_fwd_iterator const &)*arg1,(Ogre::UTFString::_const_fwd_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.-

  call-seq:
    -(left, right) -> size_type
    -(left, right) -> size_type

Substraction operator.
*/
SWIGINTERN VALUE
_wrap___sub____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_rev_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_rev_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::UTFString::size_type 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__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator -", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator -", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator -", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator -", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp2);
  result = Ogre::operator -((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___sub__(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__UTFString___const_fwd_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sub____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___sub____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__sub__", 
    "    Ogre::UTFString::size_type __sub__(Ogre::UTFString::_const_fwd_iterator const &left, Ogre::UTFString::_const_fwd_iterator const &right)\n"
    "    Ogre::UTFString::size_type __sub__(Ogre::UTFString::_const_rev_iterator const &left, Ogre::UTFString::_const_rev_iterator const &right)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.==

  call-seq:
    ==(left, right) -> bool
    ==(left, right) -> bool
    ==(lhs, rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap___eq____SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_rev_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_rev_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator ==", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator ==", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator ==", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator ==", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp2);
  result = (bool)Ogre::operator ==((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.<

  call-seq:
    <(left, right) -> bool
    <(left, right) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap___lt____SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_rev_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_rev_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp2);
  result = (bool)Ogre::operator <((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___lt__(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__UTFString___const_fwd_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lt____SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__lt__", 
    "    bool __lt__(Ogre::UTFString::_const_fwd_iterator const &left, Ogre::UTFString::_const_fwd_iterator const &right)\n"
    "    bool __lt__(Ogre::UTFString::_const_rev_iterator const &left, Ogre::UTFString::_const_rev_iterator const &right)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.<=

  call-seq:
    <=(left, right) -> bool
    <=(left, right) -> bool

Lower or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___le____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_rev_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_rev_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator <=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp2);
  result = (bool)Ogre::operator <=((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___le__(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__UTFString___const_fwd_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___le____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__le__", 
    "    bool __le__(Ogre::UTFString::_const_fwd_iterator const &left, Ogre::UTFString::_const_fwd_iterator const &right)\n"
    "    bool __le__(Ogre::UTFString::_const_rev_iterator const &left, Ogre::UTFString::_const_rev_iterator const &right)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.>

  call-seq:
    >(left, right) -> bool
    >(left, right) -> bool

Higher than comparison operator.
*/
SWIGINTERN VALUE
_wrap___gt____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_rev_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_rev_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp2);
  result = (bool)Ogre::operator >((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___gt__(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__UTFString___const_fwd_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___gt____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__gt__", 
    "    bool __gt__(Ogre::UTFString::_const_fwd_iterator const &left, Ogre::UTFString::_const_fwd_iterator const &right)\n"
    "    bool __gt__(Ogre::UTFString::_const_rev_iterator const &left, Ogre::UTFString::_const_rev_iterator const &right)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.>=

  call-seq:
    >=(left, right) -> bool
    >=(left, right) -> bool

Higher or equal comparison operator.
*/
SWIGINTERN VALUE
_wrap___ge____SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UTFString::_const_rev_iterator *arg1 = 0 ;
  Ogre::UTFString::_const_rev_iterator *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >=", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >=", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >=", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString::_const_rev_iterator const &","Ogre::operator >=", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString::_const_rev_iterator * >(argp2);
  result = (bool)Ogre::operator >=((Ogre::UTFString::_const_rev_iterator const &)*arg1,(Ogre::UTFString::_const_rev_iterator const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___ge__(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__UTFString___const_fwd_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___ge____SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__ge__", 
    "    bool __ge__(Ogre::UTFString::_const_fwd_iterator const &left, Ogre::UTFString::_const_fwd_iterator const &right)\n"
    "    bool __ge__(Ogre::UTFString::_const_rev_iterator const &left, Ogre::UTFString::_const_rev_iterator const &right)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Ogre.<<

  call-seq:
    <<(os, s) -> std::ostream
    <<(os, s) -> std::wostream

Left shifting or appending operator.
*/
SWIGINTERN VALUE
_wrap___lshift____SWIG_1(int argc, VALUE *argv, VALUE self) {
  std::ostream *arg1 = 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::ostream *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(argv[0], &argp1, SWIGTYPE_p_std__ostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::ostream &","Ogre::operator <<", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ostream &","Ogre::operator <<", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::ostream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator <<", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator <<", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (std::ostream *) &Ogre::operator <<(*arg1,(Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__ostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap___lshift____SWIG_2(int argc, VALUE *argv, VALUE self) {
  std::wostream *arg1 = 0 ;
  Ogre::UTFString *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  std::wostream *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(argv[0], &argp1, SWIGTYPE_p_std__wostream,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "std::wostream &","Ogre::operator <<", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::wostream &","Ogre::operator <<", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< std::wostream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::UTFString const &","Ogre::operator <<", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::UTFString const &","Ogre::operator <<", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::UTFString * >(argp2);
  result = (std::wostream *) &Ogre::operator <<(*arg1,(Ogre::UTFString const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__wostream, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___lshift__(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_std__ostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_std__wostream, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___lshift____SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__lshift__", 
    "    std::wostream & __lshift__(std::ostream &os, Ogre::UTFString const &s)\n"
    "    std::wostream & __lshift__(std::wostream &os, Ogre::UTFString const &s)\n");
  
  return Qnil;
}


swig_class SwigClassCmdLeft;

SWIGINTERN VALUE
_wrap_CmdLeft_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdLeft *arg1 = (Ogre::OverlayElementCommands::CmdLeft *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdLeft, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdLeft const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdLeft * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdLeft const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdLeft_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdLeft *arg1 = (Ogre::OverlayElementCommands::CmdLeft *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdLeft, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdLeft *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdLeft * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdLeft(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdLeft";
  Ogre::OverlayElementCommands::CmdLeft *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdLeft *)new Ogre::OverlayElementCommands::CmdLeft();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdLeft(Ogre::OverlayElementCommands::CmdLeft *arg1) {
    delete arg1;
}

swig_class SwigClassCmdTop;

SWIGINTERN VALUE
_wrap_CmdTop_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdTop *arg1 = (Ogre::OverlayElementCommands::CmdTop *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdTop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdTop const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdTop * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdTop const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdTop_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdTop *arg1 = (Ogre::OverlayElementCommands::CmdTop *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdTop, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdTop *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdTop * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdTop(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdTop";
  Ogre::OverlayElementCommands::CmdTop *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdTop *)new Ogre::OverlayElementCommands::CmdTop();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdTop(Ogre::OverlayElementCommands::CmdTop *arg1) {
    delete arg1;
}

swig_class SwigClassCmdWidth;

SWIGINTERN VALUE
_wrap_CmdWidth_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdWidth *arg1 = (Ogre::OverlayElementCommands::CmdWidth *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdWidth, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdWidth const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdWidth * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdWidth const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdWidth_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdWidth *arg1 = (Ogre::OverlayElementCommands::CmdWidth *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdWidth, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdWidth *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdWidth * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdWidth(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdWidth";
  Ogre::OverlayElementCommands::CmdWidth *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdWidth *)new Ogre::OverlayElementCommands::CmdWidth();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdWidth(Ogre::OverlayElementCommands::CmdWidth *arg1) {
    delete arg1;
}

swig_class SwigClassCmdHeight;

SWIGINTERN VALUE
_wrap_CmdHeight_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdHeight *arg1 = (Ogre::OverlayElementCommands::CmdHeight *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdHeight const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdHeight * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdHeight const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdHeight_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdHeight *arg1 = (Ogre::OverlayElementCommands::CmdHeight *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdHeight, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdHeight *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdHeight * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdHeight(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdHeight";
  Ogre::OverlayElementCommands::CmdHeight *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdHeight *)new Ogre::OverlayElementCommands::CmdHeight();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdHeight(Ogre::OverlayElementCommands::CmdHeight *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMaterial;

SWIGINTERN VALUE
_wrap_CmdMaterial_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdMaterial *arg1 = (Ogre::OverlayElementCommands::CmdMaterial *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdMaterial const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdMaterial const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMaterial_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdMaterial *arg1 = (Ogre::OverlayElementCommands::CmdMaterial *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdMaterial, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdMaterial *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdMaterial * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMaterial(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMaterial";
  Ogre::OverlayElementCommands::CmdMaterial *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdMaterial *)new Ogre::OverlayElementCommands::CmdMaterial();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdMaterial(Ogre::OverlayElementCommands::CmdMaterial *arg1) {
    delete arg1;
}

swig_class SwigClassCmdCaption;

SWIGINTERN VALUE
_wrap_CmdCaption_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdCaption *arg1 = (Ogre::OverlayElementCommands::CmdCaption *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdCaption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdCaption const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdCaption * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdCaption const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdCaption_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdCaption *arg1 = (Ogre::OverlayElementCommands::CmdCaption *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdCaption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdCaption *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdCaption * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdCaption(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdCaption";
  Ogre::OverlayElementCommands::CmdCaption *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdCaption *)new Ogre::OverlayElementCommands::CmdCaption();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdCaption(Ogre::OverlayElementCommands::CmdCaption *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMetricsMode;

SWIGINTERN VALUE
_wrap_CmdMetricsMode_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdMetricsMode *arg1 = (Ogre::OverlayElementCommands::CmdMetricsMode *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdMetricsMode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdMetricsMode const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdMetricsMode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdMetricsMode const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMetricsMode_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdMetricsMode *arg1 = (Ogre::OverlayElementCommands::CmdMetricsMode *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdMetricsMode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdMetricsMode *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdMetricsMode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMetricsMode(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMetricsMode";
  Ogre::OverlayElementCommands::CmdMetricsMode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdMetricsMode *)new Ogre::OverlayElementCommands::CmdMetricsMode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdMetricsMode(Ogre::OverlayElementCommands::CmdMetricsMode *arg1) {
    delete arg1;
}

swig_class SwigClassCmdHorizontalAlign;

SWIGINTERN VALUE
_wrap_CmdHorizontalAlign_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdHorizontalAlign *arg1 = (Ogre::OverlayElementCommands::CmdHorizontalAlign *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdHorizontalAlign, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdHorizontalAlign const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdHorizontalAlign * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdHorizontalAlign const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdHorizontalAlign_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdHorizontalAlign *arg1 = (Ogre::OverlayElementCommands::CmdHorizontalAlign *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdHorizontalAlign, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdHorizontalAlign *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdHorizontalAlign * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdHorizontalAlign(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdHorizontalAlign";
  Ogre::OverlayElementCommands::CmdHorizontalAlign *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdHorizontalAlign *)new Ogre::OverlayElementCommands::CmdHorizontalAlign();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdHorizontalAlign(Ogre::OverlayElementCommands::CmdHorizontalAlign *arg1) {
    delete arg1;
}

swig_class SwigClassCmdVerticalAlign;

SWIGINTERN VALUE
_wrap_CmdVerticalAlign_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdVerticalAlign *arg1 = (Ogre::OverlayElementCommands::CmdVerticalAlign *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdVerticalAlign, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdVerticalAlign const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdVerticalAlign * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdVerticalAlign const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdVerticalAlign_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdVerticalAlign *arg1 = (Ogre::OverlayElementCommands::CmdVerticalAlign *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdVerticalAlign, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdVerticalAlign *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdVerticalAlign * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdVerticalAlign(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdVerticalAlign";
  Ogre::OverlayElementCommands::CmdVerticalAlign *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdVerticalAlign *)new Ogre::OverlayElementCommands::CmdVerticalAlign();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdVerticalAlign(Ogre::OverlayElementCommands::CmdVerticalAlign *arg1) {
    delete arg1;
}

swig_class SwigClassCmdVisible;

SWIGINTERN VALUE
_wrap_CmdVisible_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdVisible *arg1 = (Ogre::OverlayElementCommands::CmdVisible *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__OverlayElementCommands__CmdVisible, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdVisible const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdVisible * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::OverlayElementCommands::CmdVisible const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdVisible_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementCommands::CmdVisible *arg1 = (Ogre::OverlayElementCommands::CmdVisible *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayElementCommands__CmdVisible, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementCommands::CmdVisible *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementCommands::CmdVisible * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdVisible(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdVisible";
  Ogre::OverlayElementCommands::CmdVisible *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayElementCommands::CmdVisible *)new Ogre::OverlayElementCommands::CmdVisible();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_OverlayElementCommands_CmdVisible(Ogre::OverlayElementCommands::CmdVisible *arg1) {
    delete arg1;
}

swig_class SwigClassRectangle;

SWIGINTERN VALUE
_wrap_Rectangle_left_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","left", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","left", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->left = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_left_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","left", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  result = (Ogre::Real) ((arg1)->left);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_top_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","top", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","top", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->top = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_top_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","top", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  result = (Ogre::Real) ((arg1)->top);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_right_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","right", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","right", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->right = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_right_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","right", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  result = (Ogre::Real) ((arg1)->right);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_bottom_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","bottom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","bottom", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->bottom = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_bottom_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle *","bottom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  result = (Ogre::Real) ((arg1)->bottom);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle_inside(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = (Ogre::Rectangle *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Rectangle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle const *","inside", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","inside", 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","inside", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)((Ogre::Rectangle const *)arg1)->inside(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Rectangle(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Rectangle";
  Ogre::Rectangle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Rectangle *)new Ogre::Rectangle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Rectangle(Ogre::Rectangle *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_intersect(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle *arg1 = 0 ;
  Ogre::Rectangle *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Rectangle 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__Rectangle,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle const &","Ogre::intersect", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle const &","Ogre::intersect", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Rectangle,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rectangle const &","Ogre::intersect", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle const &","Ogre::intersect", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Rectangle * >(argp2);
  result = Ogre::intersect((Ogre::Rectangle const &)*arg1,(Ogre::Rectangle const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Rectangle(static_cast< const Ogre::Rectangle& >(result))), SWIGTYPE_p_Ogre__Rectangle, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassOverlayElement;

SWIGINTERN void
free_Ogre_OverlayElement(Ogre::OverlayElement *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_OverlayElement_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::OverlayElement const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_show(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","show", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  (arg1)->show();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_hide(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","hide", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  (arg1)->hide();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (bool)((Ogre::OverlayElement const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_isEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","isEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (bool)((Ogre::OverlayElement const *)arg1)->isEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDimensions", 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","setDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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);
  (arg1)->setPosition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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);
  (arg1)->setWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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);
  (arg1)->setHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLeft", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setLeft(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getLeft();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setTop(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTop", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTop(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getTop(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getTop();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","_getLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getLeft();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getTop(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","_getTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getTop();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","_getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","_getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->_getHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__setLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_setLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_setLeft", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->_setLeft(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__setTop(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_setTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_setTop", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->_setTop(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__setWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_setWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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);
  (arg1)->_setWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__setHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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);
  (arg1)->_setHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__setPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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);
  (arg1)->_setPosition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__setDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_setDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_setDimensions", 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","_setDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->_setDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::OverlayElement const *)arg1)->getMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::OverlayElement const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::OverlayElement const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__positionsOutOfDate(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_positionsOutOfDate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  (arg1)->_positionsOutOfDate();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__update(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  (arg1)->_update();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__updateFromParent(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_updateFromParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  (arg1)->_updateFromParent();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__notifyParent(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::OverlayContainer *arg2 = (Ogre::OverlayContainer *) 0 ;
  Ogre::Overlay *arg3 = (Ogre::Overlay *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_notifyParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_notifyParent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayContainer * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Overlay *","_notifyParent", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Overlay * >(argp3);
  (arg1)->_notifyParent(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getDerivedLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_getDerivedLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)(arg1)->_getDerivedLeft();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getDerivedTop(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_getDerivedTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)(arg1)->_getDerivedTop();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getRelativeWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_getRelativeWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)(arg1)->_getRelativeWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getRelativeHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_getRelativeHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::Real)(arg1)->_getRelativeHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__getClippingRegion(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Rectangle *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_getClippingRegion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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 &","_getClippingRegion", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rectangle &","_getClippingRegion", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rectangle * >(argp2);
  (arg1)->_getClippingRegion(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__notifyZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::ushort 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_notifyZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","_notifyZOrder", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::ushort)(arg1)->_notifyZOrder(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__notifyWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Matrix4 *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_notifyWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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 &","_notifyWorldTransforms", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_notifyWorldTransforms", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->_notifyWorldTransforms((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__notifyViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_notifyViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  (arg1)->_notifyViewport();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayElement_visitRenderables(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_Ogre__OverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_OverlayElement_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OverlayElement_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayElement.visitRenderables", 
    "    void OverlayElement.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void OverlayElement.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::OverlayElement const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setCaption(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::DisplayString *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setCaption", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DisplayString const &","setCaption", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DisplayString const &","setCaption", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DisplayString * >(argp2);
  (arg1)->setCaption((Ogre::DisplayString const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getCaption(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::DisplayString *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getCaption", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::DisplayString *) &((Ogre::OverlayElement const *)arg1)->getCaption();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UTFString, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setColour(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::ColourValue *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getColour(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::OverlayElement const *)arg1)->getColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setMetricsMode(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::GuiMetricsMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setMetricsMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GuiMetricsMode","setMetricsMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GuiMetricsMode >(val2);
  (arg1)->setMetricsMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getMetricsMode(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GuiMetricsMode 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getMetricsMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::GuiMetricsMode)((Ogre::OverlayElement const *)arg1)->getMetricsMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setHorizontalAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::GuiHorizontalAlignment arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setHorizontalAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GuiHorizontalAlignment","setHorizontalAlignment", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GuiHorizontalAlignment >(val2);
  (arg1)->setHorizontalAlignment(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getHorizontalAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GuiHorizontalAlignment 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getHorizontalAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::GuiHorizontalAlignment)((Ogre::OverlayElement const *)arg1)->getHorizontalAlignment();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setVerticalAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::GuiVerticalAlignment arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setVerticalAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GuiVerticalAlignment","setVerticalAlignment", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GuiVerticalAlignment >(val2);
  (arg1)->setVerticalAlignment(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getVerticalAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GuiVerticalAlignment 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getVerticalAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::GuiVerticalAlignment)((Ogre::OverlayElement const *)arg1)->getVerticalAlignment();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_contains(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","contains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","contains", 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","contains", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)((Ogre::OverlayElement const *)arg1)->contains(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_findElementAt(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::OverlayElement *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","findElementAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","findElementAt", 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","findElementAt", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::OverlayElement *)(arg1)->findElementAt(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_isContainer(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","isContainer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (bool)((Ogre::OverlayElement const *)arg1)->isContainer();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_isKeyEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","isKeyEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (bool)((Ogre::OverlayElement const *)arg1)->isKeyEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_isCloneable(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","isCloneable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (bool)((Ogre::OverlayElement const *)arg1)->isCloneable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_setCloneable(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","setCloneable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCloneable", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCloneable(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::OverlayContainer *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::OverlayContainer *)(arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement__setParent(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::OverlayContainer *arg2 = (Ogre::OverlayContainer *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_setParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_setParent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayContainer * >(argp2);
  (arg1)->_setParent(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::ushort)((Ogre::OverlayElement const *)arg1)->getZOrder();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::OverlayElement const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::LightList *) &((Ogre::OverlayElement const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_copyFromTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","copyFromTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","copyFromTemplate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->copyFromTemplate(arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayElement.clone

  call-seq:
    clone(instanceName) -> OverlayElement

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_OverlayElement_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->clone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElement_getSourceTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElement *arg1 = (Ogre::OverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::OverlayElement *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_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElement const *","getSourceTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElement * >(argp1);
  result = (Ogre::OverlayElement *)((Ogre::OverlayElement const *)arg1)->getSourceTemplate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassOverlayContainer;

SWIGINTERN void
free_Ogre_OverlayContainer(Ogre::OverlayContainer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_OverlayContainer_addChild(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","addChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","addChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->addChild(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_addChildImpl__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","addChildImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","addChildImpl", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->addChildImpl(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_addChildImpl__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::OverlayContainer *arg2 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","addChildImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","addChildImpl", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayContainer * >(argp2);
  (arg1)->addChildImpl(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayContainer_addChildImpl(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_Ogre__OverlayContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__OverlayContainer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_OverlayContainer_addChildImpl__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__OverlayElement, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_OverlayContainer_addChildImpl__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "OverlayContainer.addChildImpl", 
    "    void OverlayContainer.addChildImpl(Ogre::OverlayElement *elem)\n"
    "    void OverlayContainer.addChildImpl(Ogre::OverlayContainer *cont)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_removeChild(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","removeChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(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( "", "Ogre::String const &","removeChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeChild((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_getChild(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","getChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(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( "", "Ogre::String const &","getChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->getChild((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__addChild(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_addChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_addChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->_addChild(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__removeChild__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_removeChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","_removeChild", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->_removeChild(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__removeChild__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_removeChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(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( "", "Ogre::String const &","_removeChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_removeChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->_removeChild((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayContainer__removeChild(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_Ogre__OverlayContainer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__OverlayElement, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_OverlayContainer__removeChild__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayContainer, 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_OverlayContainer__removeChild__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "OverlayContainer._removeChild", 
    "    void OverlayContainer._removeChild(Ogre::OverlayElement *elem)\n"
    "    void OverlayContainer._removeChild(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_getChildIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::OverlayElement *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::OverlayElement * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","getChildIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  result = (arg1)->getChildIterator();
  vresult = SWIG_NewPointerObj((new Ogre::OverlayContainer::ChildIterator(static_cast< const Ogre::OverlayContainer::ChildIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_getChildContainerIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::OverlayContainer *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::OverlayContainer * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","getChildContainerIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  result = (arg1)->getChildContainerIterator();
  vresult = SWIG_NewPointerObj((new Ogre::OverlayContainer::ChildContainerIterator(static_cast< const Ogre::OverlayContainer::ChildContainerIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__positionsOutOfDate(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_positionsOutOfDate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  (arg1)->_positionsOutOfDate();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__update(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  (arg1)->_update();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__notifyZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::ushort 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_notifyZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","_notifyZOrder", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::ushort)(arg1)->_notifyZOrder(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__notifyViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_notifyViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  (arg1)->_notifyViewport();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__notifyWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::Matrix4 *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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_notifyWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(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 &","_notifyWorldTransforms", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_notifyWorldTransforms", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->_notifyWorldTransforms((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__notifyParent(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::OverlayContainer *arg2 = (Ogre::OverlayContainer *) 0 ;
  Ogre::Overlay *arg3 = (Ogre::Overlay *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_notifyParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_notifyParent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayContainer * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Overlay *","_notifyParent", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Overlay * >(argp3);
  (arg1)->_notifyParent(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_isContainer(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer const *","isContainer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  result = (bool)((Ogre::OverlayContainer const *)arg1)->isContainer();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_isChildrenProcessEvents(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer const *","isChildrenProcessEvents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  result = (bool)((Ogre::OverlayContainer const *)arg1)->isChildrenProcessEvents();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_setChildrenProcessEvents(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","setChildrenProcessEvents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setChildrenProcessEvents", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setChildrenProcessEvents(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_findElementAt(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::OverlayElement *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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","findElementAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","findElementAt", 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","findElementAt", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::OverlayElement *)(arg1)->findElementAt(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_copyFromTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","copyFromTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","copyFromTemplate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->copyFromTemplate(arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::OverlayContainer.clone

  call-seq:
    clone(instanceName) -> OverlayElement

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_OverlayContainer_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->clone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_each_child(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","each_child", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  Ogre_OverlayContainer_each_child(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_each_child_container(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayContainer *arg1 = (Ogre::OverlayContainer *) 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_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","each_child_container", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayContainer * >(argp1);
  Ogre_OverlayContainer_each_child_container(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayContainer_cast(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  Ogre::OverlayContainer *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (Ogre::OverlayContainer *)Ogre_OverlayContainer_cast(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPanelOverlayElement;

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

SWIGINTERN VALUE
_wrap_new_PanelOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::PanelOverlayElement";
  Ogre::PanelOverlayElement *result = 0 ;
  
  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 &","Ogre::PanelOverlayElement", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PanelOverlayElement", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::PanelOverlayElement *)new Ogre::PanelOverlayElement((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_PanelOverlayElement(Ogre::PanelOverlayElement *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PanelOverlayElement_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_setTiling__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::ushort arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","setTiling", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTiling", 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","setTiling", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::ushort","setTiling", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::ushort >(val4);
  (arg1)->setTiling(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_setTiling__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","setTiling", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTiling", 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","setTiling", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setTiling(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PanelOverlayElement_setTiling(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_Ogre__PanelOverlayElement, 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_PanelOverlayElement_setTiling__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PanelOverlayElement, 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_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_PanelOverlayElement_setTiling__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PanelOverlayElement.setTiling", 
    "    void PanelOverlayElement.setTiling(Ogre::Real x, Ogre::Real y, Ogre::ushort layer)\n"
    "    void PanelOverlayElement.setTiling(Ogre::Real x, Ogre::Real y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_getTileX__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement const *","getTileX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","getTileX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileX(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_getTileX__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement const *","getTileX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileX();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PanelOverlayElement_getTileX(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_Ogre__PanelOverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PanelOverlayElement_getTileX__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PanelOverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PanelOverlayElement_getTileX__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PanelOverlayElement.getTileX", 
    "    Ogre::Real PanelOverlayElement.getTileX(Ogre::ushort layer)\n"
    "    Ogre::Real PanelOverlayElement.getTileX()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_getTileY__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement const *","getTileY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","getTileY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileY(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_getTileY__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement const *","getTileY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::PanelOverlayElement const *)arg1)->getTileY();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PanelOverlayElement_getTileY(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_Ogre__PanelOverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PanelOverlayElement_getTileY__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PanelOverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PanelOverlayElement_getTileY__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PanelOverlayElement.getTileY", 
    "    Ogre::Real PanelOverlayElement.getTileY(Ogre::ushort layer)\n"
    "    Ogre::Real PanelOverlayElement.getTileY()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_setUV(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","setUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setUV", 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","setUV", 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","setUV", 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","setUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_getUV(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::Real *arg2 = 0 ;
  Ogre::Real *arg3 = 0 ;
  Ogre::Real *arg4 = 0 ;
  Ogre::Real *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement const *","getUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real &","getUV", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getUV", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real &","getUV", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getUV", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real &","getUV", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getUV", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real &","getUV", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getUV", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  ((Ogre::PanelOverlayElement const *)arg1)->getUV(*arg2,*arg3,*arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_setTransparent(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","setTransparent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTransparent", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTransparent(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_isTransparent(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement const *","isTransparent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  result = (bool)((Ogre::PanelOverlayElement const *)arg1)->isTransparent();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::PanelOverlayElement const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::RenderOperation *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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_setMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElement *arg1 = (Ogre::PanelOverlayElement *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__PanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElement *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElement_cast(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  Ogre::PanelOverlayElement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (Ogre::PanelOverlayElement *)Ogre_PanelOverlayElement_cast(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PanelOverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassBorderPanelOverlayElement;

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

SWIGINTERN VALUE
_wrap_new_BorderPanelOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::BorderPanelOverlayElement";
  Ogre::BorderPanelOverlayElement *result = 0 ;
  
  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 &","Ogre::BorderPanelOverlayElement", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::BorderPanelOverlayElement", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::BorderPanelOverlayElement *)new Ogre::BorderPanelOverlayElement((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_BorderPanelOverlayElement(Ogre::BorderPanelOverlayElement *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::BorderPanelOverlayElement const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setBorderSize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setBorderSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setBorderSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setBorderSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setBorderSize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setBorderSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setBorderSize", 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","setBorderSize", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setBorderSize(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setBorderSize__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setBorderSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setBorderSize", 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","setBorderSize", 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","setBorderSize", 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","setBorderSize", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setBorderSize(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BorderPanelOverlayElement_setBorderSize(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_Ogre__BorderPanelOverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_BorderPanelOverlayElement_setBorderSize__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BorderPanelOverlayElement, 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_BorderPanelOverlayElement_setBorderSize__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BorderPanelOverlayElement, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_BorderPanelOverlayElement_setBorderSize__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "BorderPanelOverlayElement.setBorderSize", 
    "    void BorderPanelOverlayElement.setBorderSize(Ogre::Real size)\n"
    "    void BorderPanelOverlayElement.setBorderSize(Ogre::Real sides, Ogre::Real topAndBottom)\n"
    "    void BorderPanelOverlayElement.setBorderSize(Ogre::Real left, Ogre::Real right, Ogre::Real top, Ogre::Real bottom)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getLeftBorderSize(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getLeftBorderSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getLeftBorderSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getRightBorderSize(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getRightBorderSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getRightBorderSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getTopBorderSize(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getTopBorderSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getTopBorderSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getBottomBorderSize(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getBottomBorderSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomBorderSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setLeftBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setLeftBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLeftBorderUV", 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","setLeftBorderUV", 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","setLeftBorderUV", 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","setLeftBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setLeftBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setRightBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setRightBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRightBorderUV", 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","setRightBorderUV", 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","setRightBorderUV", 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","setRightBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setRightBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setTopBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setTopBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTopBorderUV", 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","setTopBorderUV", 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","setTopBorderUV", 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","setTopBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setTopBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setBottomBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setBottomBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setBottomBorderUV", 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","setBottomBorderUV", 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","setBottomBorderUV", 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","setBottomBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setBottomBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setTopLeftBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setTopLeftBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTopLeftBorderUV", 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","setTopLeftBorderUV", 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","setTopLeftBorderUV", 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","setTopLeftBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setTopLeftBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setTopRightBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setTopRightBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTopRightBorderUV", 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","setTopRightBorderUV", 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","setTopRightBorderUV", 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","setTopRightBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setTopRightBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setBottomLeftBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setBottomLeftBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setBottomLeftBorderUV", 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","setBottomLeftBorderUV", 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","setBottomLeftBorderUV", 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","setBottomLeftBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setBottomLeftBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setBottomRightBorderUV(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setBottomRightBorderUV", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setBottomRightBorderUV", 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","setBottomRightBorderUV", 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","setBottomRightBorderUV", 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","setBottomRightBorderUV", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setBottomRightBorderUV(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getLeftBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getLeftBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getLeftBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getRightBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getRightBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getRightBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getTopBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getTopBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getTopBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getBottomBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getBottomBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getTopLeftBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getTopLeftBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getTopLeftBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getTopRightBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getTopRightBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getTopRightBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getBottomLeftBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getBottomLeftBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomLeftBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getBottomRightBorderUVString(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getBottomRightBorderUVString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = ((Ogre::BorderPanelOverlayElement const *)arg1)->getBottomRightBorderUVString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setBorderMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setBorderMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(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( "", "Ogre::String const &","setBorderMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setBorderMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setBorderMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_getBorderMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement const *","getBorderMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::BorderPanelOverlayElement const *)arg1)->getBorderMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_BorderPanelOverlayElement_visitRenderables(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_Ogre__BorderPanelOverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_BorderPanelOverlayElement_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__BorderPanelOverlayElement, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_BorderPanelOverlayElement_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "BorderPanelOverlayElement.visitRenderables", 
    "    void BorderPanelOverlayElement.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void BorderPanelOverlayElement.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_setMetricsMode(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  Ogre::GuiMetricsMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","setMetricsMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GuiMetricsMode","setMetricsMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GuiMetricsMode >(val2);
  (arg1)->setMetricsMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement__update(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 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_Ogre__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","_update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  (arg1)->_update();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElement_cast(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  Ogre::BorderPanelOverlayElement *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (Ogre::BorderPanelOverlayElement *)Ogre_BorderPanelOverlayElement_cast(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BorderPanelOverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassBorderRenderable;

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

SWIGINTERN VALUE
_wrap_new_BorderRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElement *arg1 = (Ogre::BorderPanelOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::BorderRenderable";
  Ogre::BorderRenderable *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__BorderPanelOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElement *","Ogre::BorderRenderable", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElement * >(argp1);
  result = (Ogre::BorderRenderable *)new Ogre::BorderRenderable(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderRenderable_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderRenderable *arg1 = (Ogre::BorderRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__BorderRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderRenderable const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderRenderable * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::BorderRenderable const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderRenderable_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderRenderable *arg1 = (Ogre::BorderRenderable *) 0 ;
  Ogre::RenderOperation *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_Ogre__BorderRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderRenderable *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderRenderable_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderRenderable *arg1 = (Ogre::BorderRenderable *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__BorderRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderRenderable const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::BorderRenderable const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderRenderable_getNumWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderRenderable *arg1 = (Ogre::BorderRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__BorderRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderRenderable const *","getNumWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderRenderable * >(argp1);
  result = (unsigned short)((Ogre::BorderRenderable const *)arg1)->getNumWorldTransforms();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderRenderable_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderRenderable *arg1 = (Ogre::BorderRenderable *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__BorderRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderRenderable const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::BorderRenderable const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderRenderable_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderRenderable *arg1 = (Ogre::BorderRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__BorderRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderRenderable const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderRenderable * >(argp1);
  result = (Ogre::LightList *) &((Ogre::BorderRenderable const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderRenderable_getPolygonModeOverrideable(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderRenderable *arg1 = (Ogre::BorderRenderable *) 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_Ogre__BorderRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderRenderable const *","getPolygonModeOverrideable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderRenderable * >(argp1);
  result = (bool)((Ogre::BorderRenderable const *)arg1)->getPolygonModeOverrideable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BorderRenderable(Ogre::BorderRenderable *arg1) {
    delete arg1;
}

swig_class SwigClassFrustum;

SWIGINTERN VALUE
_wrap_new_Frustum__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Frustum";
  Ogre::Frustum *result = 0 ;
  
  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 &","Ogre::Frustum", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Frustum", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Frustum *)new Ogre::Frustum((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Frustum__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Frustum";
  Ogre::Frustum *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Frustum *)new Ogre::Frustum();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Frustum(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_Frustum__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_new_Frustum__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Frustum.new", 
    "    Frustum.new(Ogre::String const &name)\n"
    "    Frustum.new()\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Frustum(Ogre::Frustum *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Frustum_setFOVy(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Radian *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFOVy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(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 const &","setFOVy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setFOVy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setFOVy((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getFOVy(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getFOVy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Radian *) &((Ogre::Frustum const *)arg1)->getFOVy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setNearClipDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setNearClipDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getNearClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFarClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFarClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFarClipDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setFarClipDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getFarClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getFarClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getFarClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setAspectRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setAspectRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setAspectRatio", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setAspectRatio(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getAspectRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getAspectRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getAspectRatio();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFrustumOffset__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Vector2 *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFrustumOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(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 &","setFrustumOffset", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setFrustumOffset", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->setFrustumOffset((Ogre::Vector2 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFrustumOffset__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFrustumOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFrustumOffset", 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","setFrustumOffset", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setFrustumOffset(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFrustumOffset__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFrustumOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFrustumOffset", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setFrustumOffset(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFrustumOffset__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFrustumOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  (arg1)->setFrustumOffset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_setFrustumOffset(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Frustum_setFrustumOffset__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 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_Frustum_setFrustumOffset__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Frustum_setFrustumOffset__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 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_Frustum_setFrustumOffset__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.setFrustumOffset", 
    "    void Frustum.setFrustumOffset(Ogre::Vector2 const &offset)\n"
    "    void Frustum.setFrustumOffset(Ogre::Real horizontal, Ogre::Real vertical)\n"
    "    void Frustum.setFrustumOffset(Ogre::Real horizontal)\n"
    "    void Frustum.setFrustumOffset()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getFrustumOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getFrustumOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Vector2 *) &((Ogre::Frustum const *)arg1)->getFrustumOffset();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFocalLength__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFocalLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFocalLength", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setFocalLength(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFocalLength__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFocalLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  (arg1)->setFocalLength();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_setFocalLength(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Frustum_setFocalLength__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Frustum_setFocalLength__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Frustum.setFocalLength", 
    "    void Frustum.setFocalLength(Ogre::Real focalLength)\n"
    "    void Frustum.setFocalLength()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getFocalLength(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getFocalLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getFocalLength();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setFrustumExtents(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setFrustumExtents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFrustumExtents", 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","setFrustumExtents", 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","setFrustumExtents", 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","setFrustumExtents", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setFrustumExtents(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_resetFrustumExtents(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","resetFrustumExtents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  (arg1)->resetFrustumExtents();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getFrustumExtents(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real *arg2 = 0 ;
  Ogre::Real *arg3 = 0 ;
  Ogre::Real *arg4 = 0 ;
  Ogre::Real *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getFrustumExtents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real &","getFrustumExtents", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getFrustumExtents", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real &","getFrustumExtents", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getFrustumExtents", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real &","getFrustumExtents", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getFrustumExtents", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real &","getFrustumExtents", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getFrustumExtents", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  ((Ogre::Frustum const *)arg1)->getFrustumExtents(*arg2,*arg3,*arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getProjectionMatrixRS(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getProjectionMatrixRS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getProjectionMatrixRS();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getProjectionMatrixWithRSDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getProjectionMatrixWithRSDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getProjectionMatrixWithRSDepth();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getProjectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getProjectionMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getViewMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_calcViewMatrixRelative(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","calcViewMatrixRelative", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(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 &","calcViewMatrixRelative", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","calcViewMatrixRelative", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","calcViewMatrixRelative", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","calcViewMatrixRelative", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  ((Ogre::Frustum const *)arg1)->calcViewMatrixRelative((Ogre::Vector3 const &)*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setCustomViewMatrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  bool arg2 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setCustomViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCustomViewMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","setCustomViewMatrix", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","setCustomViewMatrix", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  (arg1)->setCustomViewMatrix(arg2,(Ogre::Matrix4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setCustomViewMatrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setCustomViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCustomViewMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCustomViewMatrix(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_setCustomViewMatrix(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Frustum_setCustomViewMatrix__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Frustum_setCustomViewMatrix__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.setCustomViewMatrix", 
    "    void Frustum.setCustomViewMatrix(bool enable, Ogre::Matrix4 const &viewMatrix)\n"
    "    void Frustum.setCustomViewMatrix(bool enable)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isCustomViewMatrixEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isCustomViewMatrixEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (bool)((Ogre::Frustum const *)arg1)->isCustomViewMatrixEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setCustomProjectionMatrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  bool arg2 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setCustomProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCustomProjectionMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","setCustomProjectionMatrix", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","setCustomProjectionMatrix", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  (arg1)->setCustomProjectionMatrix(arg2,(Ogre::Matrix4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setCustomProjectionMatrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setCustomProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCustomProjectionMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCustomProjectionMatrix(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_setCustomProjectionMatrix(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Frustum_setCustomProjectionMatrix__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Frustum_setCustomProjectionMatrix__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.setCustomProjectionMatrix", 
    "    void Frustum.setCustomProjectionMatrix(bool enable, Ogre::Matrix4 const &projectionMatrix)\n"
    "    void Frustum.setCustomProjectionMatrix(bool enable)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isCustomProjectionMatrixEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isCustomProjectionMatrixEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (bool)((Ogre::Frustum const *)arg1)->isCustomProjectionMatrixEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getFrustumPlanes(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Plane *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getFrustumPlanes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Plane *)((Ogre::Frustum const *)arg1)->getFrustumPlanes();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getFrustumPlane(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Plane *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getFrustumPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(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","getFrustumPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Plane *) &((Ogre::Frustum const *)arg1)->getFrustumPlane(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isVisible__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::FrustumPlane *arg3 = (Ogre::FrustumPlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__FrustumPlane, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::FrustumPlane *","isVisible", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::FrustumPlane * >(argp3);
  result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isVisible__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isVisible__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  Ogre::FrustumPlane *arg3 = (Ogre::FrustumPlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__FrustumPlane, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::FrustumPlane *","isVisible", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::FrustumPlane * >(argp3);
  result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Sphere const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isVisible__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Sphere *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Sphere const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isVisible__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::FrustumPlane *arg3 = (Ogre::FrustumPlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(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 &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__FrustumPlane, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::FrustumPlane *","isVisible", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::FrustumPlane * >(argp3);
  result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isVisible__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Vector3 *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(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 &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Frustum const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_isVisible(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Frustum_isVisible__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Frustum_isVisible__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 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_Frustum_isVisible__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__FrustumPlane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Frustum_isVisible__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 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__FrustumPlane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Frustum_isVisible__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__FrustumPlane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Frustum_isVisible__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.isVisible", 
    "    bool Frustum.isVisible(Ogre::AxisAlignedBox const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Frustum.isVisible(Ogre::AxisAlignedBox const &bound)\n"
    "    bool Frustum.isVisible(Ogre::Sphere const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Frustum.isVisible(Ogre::Sphere const &bound)\n"
    "    bool Frustum.isVisible(Ogre::Vector3 const &vert, Ogre::FrustumPlane *culledBy)\n"
    "    bool Frustum.isVisible(Ogre::Vector3 const &vert)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::uint32)((Ogre::Frustum const *)arg1)->getTypeFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::Frustum const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::String *) &((Ogre::Frustum const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::Frustum const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::RenderOperation *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::Frustum const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::LightList *) &((Ogre::Frustum const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getWorldSpaceCorners(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getWorldSpaceCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Vector3 *)((Ogre::Frustum const *)arg1)->getWorldSpaceCorners();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setProjectionType(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::ProjectionType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setProjectionType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ProjectionType","setProjectionType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ProjectionType >(val2);
  (arg1)->setProjectionType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getProjectionType(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ProjectionType 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getProjectionType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::ProjectionType)((Ogre::Frustum const *)arg1)->getProjectionType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setOrthoWindow(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setOrthoWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOrthoWindow", 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","setOrthoWindow", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setOrthoWindow(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setOrthoWindowHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setOrthoWindowHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOrthoWindowHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setOrthoWindowHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setOrthoWindowWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setOrthoWindowWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOrthoWindowWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setOrthoWindowWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getOrthoWindowHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getOrthoWindowHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getOrthoWindowHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getOrthoWindowWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getOrthoWindowWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Real)((Ogre::Frustum const *)arg1)->getOrthoWindowWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_enableReflection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Plane *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","enableReflection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","enableReflection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","enableReflection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  (arg1)->enableReflection((Ogre::Plane const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_enableReflection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::MovablePlane *arg2 = (Ogre::MovablePlane *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","enableReflection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovablePlane const *","enableReflection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovablePlane * >(argp2);
  (arg1)->enableReflection((Ogre::MovablePlane const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_enableReflection(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovablePlane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Frustum_enableReflection__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Frustum_enableReflection__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Frustum.enableReflection", 
    "    void Frustum.enableReflection(Ogre::Plane const &p)\n"
    "    void Frustum.enableReflection(Ogre::MovablePlane const *p)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_disableReflection(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","disableReflection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  (arg1)->disableReflection();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isReflected(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isReflected", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (bool)((Ogre::Frustum const *)arg1)->isReflected();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getReflectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getReflectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::Frustum const *)arg1)->getReflectionMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getReflectionPlane(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Plane *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getReflectionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Plane *) &((Ogre::Frustum const *)arg1)->getReflectionPlane();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_projectSphere(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  Ogre::Real *arg3 = (Ogre::Real *) 0 ;
  Ogre::Real *arg4 = (Ogre::Real *) 0 ;
  Ogre::Real *arg5 = (Ogre::Real *) 0 ;
  Ogre::Real *arg6 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","projectSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","projectSphere", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","projectSphere", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Real * >(argp6);
  result = (bool)((Ogre::Frustum const *)arg1)->projectSphere((Ogre::Sphere const &)*arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_enableCustomNearClipPlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::MovablePlane *arg2 = (Ogre::MovablePlane *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","enableCustomNearClipPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovablePlane const *","enableCustomNearClipPlane", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovablePlane * >(argp2);
  (arg1)->enableCustomNearClipPlane((Ogre::MovablePlane const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_enableCustomNearClipPlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Plane *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","enableCustomNearClipPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","enableCustomNearClipPlane", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","enableCustomNearClipPlane", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  (arg1)->enableCustomNearClipPlane((Ogre::Plane const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_enableCustomNearClipPlane(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovablePlane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Frustum_enableCustomNearClipPlane__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Frustum_enableCustomNearClipPlane__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Frustum.enableCustomNearClipPlane", 
    "    void Frustum.enableCustomNearClipPlane(Ogre::MovablePlane const *plane)\n"
    "    void Frustum.enableCustomNearClipPlane(Ogre::Plane const &plane)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_disableCustomNearClipPlane(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","disableCustomNearClipPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  (arg1)->disableCustomNearClipPlane();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_isCustomNearClipPlaneEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","isCustomNearClipPlaneEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (bool)((Ogre::Frustum const *)arg1)->isCustomNearClipPlaneEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Frustum_visitRenderables(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_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Frustum_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Frustum_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Frustum.visitRenderables", 
    "    void Frustum.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void Frustum.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_INFINITE_FAR_PLANE_ADJUST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_float(static_cast< float >(Ogre::Frustum::INFINITE_FAR_PLANE_ADJUST));
  return _val;
}


SWIGINTERN VALUE
_wrap_Frustum_getPositionForViewUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getPositionForViewUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Frustum const *)arg1)->getPositionForViewUpdate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getOrientationForViewUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getOrientationForViewUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Frustum const *)arg1)->getOrientationForViewUpdate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getPlaneBoundedVolume(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PlaneBoundedVolume 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","getPlaneBoundedVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (arg1)->getPlaneBoundedVolume();
  vresult = SWIG_NewPointerObj((new Ogre::PlaneBoundedVolume(static_cast< const Ogre::PlaneBoundedVolume& >(result))), SWIGTYPE_p_Ogre__PlaneBoundedVolume, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_setOrientationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  Ogre::OrientationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum *","setOrientationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::OrientationMode","setOrientationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::OrientationMode >(val2);
  (arg1)->setOrientationMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Frustum_getOrientationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Frustum *arg1 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::OrientationMode 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_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Frustum const *","getOrientationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Frustum * >(argp1);
  result = (Ogre::OrientationMode)((Ogre::Frustum const *)arg1)->getOrientationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRay;

SWIGINTERN VALUE
_wrap_new_Ray__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Ray";
  Ogre::Ray *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Ray *)new Ogre::Ray();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Ray__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 = "Ogre::Ray";
  Ogre::Ray *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 &","Ogre::Ray", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Ray", 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 &","Ogre::Ray", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Ray", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Ray *)new Ogre::Ray((Ogre::Vector3 const &)*arg1,(Ogre::Vector3 const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Ray(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_Ray__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_Ray__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Ray.new", 
    "    Ray.new()\n"
    "    Ray.new(Ogre::Vector3 const &origin, Ogre::Vector3 const &direction)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_setOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  Ogre::Vector3 *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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray *","setOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","setOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Ray const *)arg1)->getOrigin();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_setDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  Ogre::Vector3 *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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(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 &","setDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_getDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","getDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Ray const *)arg1)->getDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_getPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","getPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Ray const *)arg1)->getPoint(arg2);
  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_Ray___mul__(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","operator *", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","operator *", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = ((Ogre::Ray const *)arg1)->operator *(arg2);
  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_Ray_intersects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  Ogre::Plane *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  result = ((Ogre::Ray const *)arg1)->intersects((Ogre::Plane const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_intersects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  Ogre::PlaneBoundedVolume *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PlaneBoundedVolume,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PlaneBoundedVolume const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp2);
  result = ((Ogre::Ray const *)arg1)->intersects((Ogre::PlaneBoundedVolume const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_intersects__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = ((Ogre::Ray const *)arg1)->intersects((Ogre::Sphere const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Ray_intersects__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Ray *arg1 = (Ogre::Ray *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,float > > 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_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Ray const *","intersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Ray * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","intersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = ((Ogre::Ray const *)arg1)->intersects((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Real >(static_cast< const std::pair< bool,Ogre::Real >& >(result))), SWIGTYPE_p_std__pairT_bool_float_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Ray_intersects(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_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Ray_intersects__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Ray_intersects__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Ray_intersects__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Ray_intersects__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Ray.intersects", 
    "    std::pair< bool,Ogre::Real > Ray.intersects(Ogre::Plane const &p)\n"
    "    std::pair< bool,Ogre::Real > Ray.intersects(Ogre::PlaneBoundedVolume const &p)\n"
    "    std::pair< bool,Ogre::Real > Ray.intersects(Ogre::Sphere const &s)\n"
    "    std::pair< bool,Ogre::Real > Ray.intersects(Ogre::AxisAlignedBox const &box)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Ray(Ogre::Ray *arg1) {
    delete arg1;
}

swig_class SwigClassCamera;

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

SWIGINTERN VALUE
_wrap_new_Camera(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Camera";
  Ogre::Camera *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::Camera", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Camera", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::Camera", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  result = (Ogre::Camera *)new Ogre::Camera((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_Camera(Ogre::Camera *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Camera_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Camera::Listener *arg2 = (Ogre::Camera::Listener *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Camera::Listener *arg2 = (Ogre::Camera::Listener *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::Camera const *)arg1)->getSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setPolygonMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::PolygonMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setPolygonMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PolygonMode","setPolygonMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PolygonMode >(val2);
  (arg1)->setPolygonMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getPolygonMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PolygonMode 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getPolygonMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::PolygonMode)((Ogre::Camera const *)arg1)->getPolygonMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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 ;
  
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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);
  (arg1)->setPosition(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_setPosition(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_Ogre__Camera, 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_Camera_setPosition__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_Camera_setPosition__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.setPosition", 
    "    void Camera.setPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Camera.setPosition(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_move(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","move", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","move", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","move", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->move((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_moveRelative(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","moveRelative", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","moveRelative", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","moveRelative", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->moveRelative((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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 ;
  
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDirection", 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","setDirection", 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","setDirection", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setDirection(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","setDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_setDirection(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_Ogre__Camera, 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_Camera_setDirection__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_Camera_setDirection__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.setDirection", 
    "    void Camera.setDirection(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void Camera.setDirection(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getDirection();
  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_Camera_getUp(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getUp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getUp();
  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_Camera_getRight(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getRight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getRight();
  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_Camera_lookAt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","lookAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","lookAt", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","lookAt", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->lookAt((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_lookAt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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 ;
  
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","lookAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","lookAt", 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","lookAt", 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","lookAt", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->lookAt(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_lookAt(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_Ogre__Camera, 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_Camera_lookAt__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_Camera_lookAt__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.lookAt", 
    "    void Camera.lookAt(Ogre::Vector3 const &targetPoint)\n"
    "    void Camera.lookAt(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_roll(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Radian *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","roll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 const &","roll", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","roll", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->roll((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_yaw(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Radian *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","yaw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 const &","yaw", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","yaw", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->yaw((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_pitch(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Radian *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","pitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 const &","pitch", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","pitch", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->pitch((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_rotate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Radian *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","rotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","rotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Radian,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Radian const &","rotate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","rotate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Radian * >(argp3);
  (arg1)->rotate((Ogre::Vector3 const &)*arg2,(Ogre::Radian const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_rotate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Quaternion *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","rotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","rotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->rotate((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_rotate(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_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Camera_rotate__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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__Radian, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Camera_rotate__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Camera.rotate", 
    "    void Camera.rotate(Ogre::Vector3 const &axis, Ogre::Radian const &angle)\n"
    "    void Camera.rotate(Ogre::Quaternion const &q)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setFixedYawAxis__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setFixedYawAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFixedYawAxis", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(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 &","setFixedYawAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setFixedYawAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->setFixedYawAxis(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setFixedYawAxis__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setFixedYawAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFixedYawAxis", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFixedYawAxis(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_setFixedYawAxis(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_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Camera_setFixedYawAxis__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Camera_setFixedYawAxis__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Camera.setFixedYawAxis", 
    "    void Camera.setFixedYawAxis(bool useFixed, Ogre::Vector3 const &fixedAxis)\n"
    "    void Camera.setFixedYawAxis(bool useFixed)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Quaternion *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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);
  (arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__renderScene(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","_renderScene", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","_renderScene", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_renderScene", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_renderScene(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__notifyRenderedFaces(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyRenderedFaces", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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","_notifyRenderedFaces", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->_notifyRenderedFaces(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__notifyRenderedBatches(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyRenderedBatches", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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","_notifyRenderedBatches", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->_notifyRenderedBatches(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__getNumRenderedFaces(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","_getNumRenderedFaces", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (unsigned int)((Ogre::Camera const *)arg1)->_getNumRenderedFaces();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__getNumRenderedBatches(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","_getNumRenderedBatches", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (unsigned int)((Ogre::Camera const *)arg1)->_getNumRenderedBatches();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getDerivedOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getDerivedOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getDerivedOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getDerivedPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getDerivedPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getDerivedPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getDerivedDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getDerivedDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getDerivedDirection();
  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_Camera_getDerivedUp(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getDerivedUp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getDerivedUp();
  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_Camera_getDerivedRight(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getDerivedRight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getDerivedRight();
  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_Camera_getRealOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getRealOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getRealOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getRealPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getRealPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getRealPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getRealDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getRealDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getRealDirection();
  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_Camera_getRealUp(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getRealUp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getRealUp();
  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_Camera_getRealRight(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getRealRight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = ((Ogre::Camera const *)arg1)->getRealRight();
  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_Camera_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::Camera const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::String *) &((Ogre::Camera const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setAutoTracking__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) (Ogre::SceneNode *)0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setAutoTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *const","setAutoTracking", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(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 &","setAutoTracking", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setAutoTracking", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->setAutoTracking(arg2,arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setAutoTracking__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) (Ogre::SceneNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setAutoTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *const","setAutoTracking", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(argp3);
  (arg1)->setAutoTracking(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setAutoTracking__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setAutoTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoTracking(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_setAutoTracking(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_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Camera_setAutoTracking__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Camera_setAutoTracking__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_Camera_setAutoTracking__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.setAutoTracking", 
    "    void Camera.setAutoTracking(bool enabled, Ogre::SceneNode *const target, Ogre::Vector3 const &offset)\n"
    "    void Camera.setAutoTracking(bool enabled, Ogre::SceneNode *const target)\n"
    "    void Camera.setAutoTracking(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setLodBias__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setLodBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setLodBias__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  (arg1)->setLodBias();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_setLodBias(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_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Camera_setLodBias__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Camera_setLodBias__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Camera.setLodBias", 
    "    void Camera.setLodBias(Ogre::Real factor)\n"
    "    void Camera.setLodBias()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getLodBias(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Real)((Ogre::Camera const *)arg1)->getLodBias();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setLodCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setLodCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","setLodCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->setLodCamera((Ogre::Camera const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getLodCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Camera *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getLodCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Camera *)((Ogre::Camera const *)arg1)->getLodCamera();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getCameraToViewportRay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Ray 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getCameraToViewportRay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCameraToViewportRay", 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","getCameraToViewportRay", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = ((Ogre::Camera const *)arg1)->getCameraToViewportRay(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Ray(static_cast< const Ogre::Ray& >(result))), SWIGTYPE_p_Ogre__Ray, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getCameraToViewportRay__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Ray *arg4 = (Ogre::Ray *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getCameraToViewportRay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCameraToViewportRay", 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","getCameraToViewportRay", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Ray *","getCameraToViewportRay", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Ray * >(argp4);
  ((Ogre::Camera const *)arg1)->getCameraToViewportRay(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_getCameraToViewportRay(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_Ogre__Camera, 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_Camera_getCameraToViewportRay__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Camera_getCameraToViewportRay__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Camera.getCameraToViewportRay", 
    "    void Camera.getCameraToViewportRay(Ogre::Real screenx, Ogre::Real screeny)\n"
    "    void Camera.getCameraToViewportRay(Ogre::Real screenx, Ogre::Real screeny, Ogre::Ray *outRay)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getCameraToViewportBoxVolume__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::PlaneBoundedVolume result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","getCameraToViewportBoxVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","getCameraToViewportBoxVolume", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::PlaneBoundedVolume(static_cast< const Ogre::PlaneBoundedVolume& >(result))), SWIGTYPE_p_Ogre__PlaneBoundedVolume, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getCameraToViewportBoxVolume__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  Ogre::PlaneBoundedVolume result;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","getCameraToViewportBoxVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  result = (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::PlaneBoundedVolume(static_cast< const Ogre::PlaneBoundedVolume& >(result))), SWIGTYPE_p_Ogre__PlaneBoundedVolume, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getCameraToViewportBoxVolume__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::PlaneBoundedVolume *arg6 = (Ogre::PlaneBoundedVolume *) 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","getCameraToViewportBoxVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume *","getCameraToViewportBoxVolume", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","getCameraToViewportBoxVolume", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getCameraToViewportBoxVolume__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::PlaneBoundedVolume *arg6 = (Ogre::PlaneBoundedVolume *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","getCameraToViewportBoxVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 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","getCameraToViewportBoxVolume", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolume *","getCameraToViewportBoxVolume", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::PlaneBoundedVolume * >(argp6);
  (arg1)->getCameraToViewportBoxVolume(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_getCameraToViewportBoxVolume(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Camera_getCameraToViewportBoxVolume__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Camera_getCameraToViewportBoxVolume__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Camera_getCameraToViewportBoxVolume__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__PlaneBoundedVolume, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Camera_getCameraToViewportBoxVolume__SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Camera.getCameraToViewportBoxVolume", 
    "    void Camera.getCameraToViewportBoxVolume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom, bool includeFarPlane)\n"
    "    void Camera.getCameraToViewportBoxVolume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom)\n"
    "    void Camera.getCameraToViewportBoxVolume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom, Ogre::PlaneBoundedVolume *outVolume, bool includeFarPlane)\n"
    "    void Camera.getCameraToViewportBoxVolume(Ogre::Real screenLeft, Ogre::Real screenTop, Ogre::Real screenRight, Ogre::Real screenBottom, Ogre::PlaneBoundedVolume *outVolume)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__getLodBiasInverse(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","_getLodBiasInverse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Real)((Ogre::Camera const *)arg1)->_getLodBiasInverse();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__autoTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","_autoTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  (arg1)->_autoTrack();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setWindow(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setWindow", 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","setWindow", 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","setWindow", 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","setWindow", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setWindow(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_resetWindow(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","resetWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  (arg1)->resetWindow();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_isWindowSet(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","isWindowSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (bool)((Ogre::Camera const *)arg1)->isWindowSet();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getWindowPlanes(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getWindowPlanes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::vector< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type *) &((Ogre::Camera const *)arg1)->getWindowPlanes();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Real)((Ogre::Camera const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getAutoTrackTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getAutoTrackTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::SceneNode *)((Ogre::Camera const *)arg1)->getAutoTrackTarget();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getAutoTrackOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getAutoTrackOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getAutoTrackOffset();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Viewport *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Viewport *)((Ogre::Camera const *)arg1)->getViewport();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera__notifyViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","_notifyViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->_notifyViewport(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setAutoAspectRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setAutoAspectRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoAspectRatio", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoAspectRatio(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getAutoAspectRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getAutoAspectRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (bool)((Ogre::Camera const *)arg1)->getAutoAspectRatio();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setCullingFrustum(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Frustum *arg2 = (Ogre::Frustum *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setCullingFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Frustum *","setCullingFrustum", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Frustum * >(argp2);
  (arg1)->setCullingFrustum(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getCullingFrustum(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Frustum *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getCullingFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Frustum *)((Ogre::Camera const *)arg1)->getCullingFrustum();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Frustum, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_forwardIntersect(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Plane *arg2 = 0 ;
  Ogre::vector< Ogre::Vector4,Ogre::STLAllocator< Ogre::Vector4,Ogre::GeneralAllocPolicy > >::type *arg3 = (Ogre::vector< Ogre::Vector4,Ogre::STLAllocator< Ogre::Vector4,Ogre::GeneralAllocPolicy > >::type *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","forwardIntersect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","forwardIntersect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","forwardIntersect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::vector< Ogre::Vector4,Ogre::STLAllocator< Ogre::Vector4,Ogre::GeneralAllocPolicy > >::type *","forwardIntersect", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::vector< Ogre::Vector4,Ogre::STLAllocator< Ogre::Vector4,Ogre::GeneralAllocPolicy > >::type * >(argp3);
  ((Ogre::Camera const *)arg1)->forwardIntersect((Ogre::Plane const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_isVisible__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::FrustumPlane *arg3 = (Ogre::FrustumPlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__FrustumPlane, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::FrustumPlane *","isVisible", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::FrustumPlane * >(argp3);
  result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_isVisible__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_isVisible__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  Ogre::FrustumPlane *arg3 = (Ogre::FrustumPlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__FrustumPlane, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::FrustumPlane *","isVisible", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::FrustumPlane * >(argp3);
  result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Sphere const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_isVisible__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Sphere *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Sphere const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_isVisible__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::FrustumPlane *arg3 = (Ogre::FrustumPlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__FrustumPlane, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::FrustumPlane *","isVisible", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::FrustumPlane * >(argp3);
  result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_isVisible__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Vector3 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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 &","isVisible", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","isVisible", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Camera const *)arg1)->isVisible((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_isVisible(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_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Camera_isVisible__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Camera_isVisible__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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_Camera_isVisible__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__FrustumPlane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Camera_isVisible__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 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__FrustumPlane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Camera_isVisible__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__FrustumPlane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Camera_isVisible__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Camera.isVisible", 
    "    bool Camera.isVisible(Ogre::AxisAlignedBox const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Camera.isVisible(Ogre::AxisAlignedBox const &bound)\n"
    "    bool Camera.isVisible(Ogre::Sphere const &bound, Ogre::FrustumPlane *culledBy)\n"
    "    bool Camera.isVisible(Ogre::Sphere const &bound)\n"
    "    bool Camera.isVisible(Ogre::Vector3 const &vert, Ogre::FrustumPlane *culledBy)\n"
    "    bool Camera.isVisible(Ogre::Vector3 const &vert)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getWorldSpaceCorners(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getWorldSpaceCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Vector3 *)((Ogre::Camera const *)arg1)->getWorldSpaceCorners();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getFrustumPlane(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Plane *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getFrustumPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(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","getFrustumPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Plane *) &((Ogre::Camera const *)arg1)->getFrustumPlane(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_projectSphere(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  Ogre::Real *arg3 = (Ogre::Real *) 0 ;
  Ogre::Real *arg4 = (Ogre::Real *) 0 ;
  Ogre::Real *arg5 = (Ogre::Real *) 0 ;
  Ogre::Real *arg6 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","projectSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","projectSphere", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","projectSphere", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Real *","projectSphere", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Real * >(argp6);
  result = (bool)((Ogre::Camera const *)arg1)->projectSphere((Ogre::Sphere const &)*arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getNearClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getNearClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Real)((Ogre::Camera const *)arg1)->getNearClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getFarClipDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getFarClipDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Real)((Ogre::Camera const *)arg1)->getFarClipDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getViewMatrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::Camera const *)arg1)->getViewMatrix();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getViewMatrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Matrix4 *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getViewMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Matrix4 *) &((Ogre::Camera const *)arg1)->getViewMatrix(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Camera_getViewMatrix(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_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Camera_getViewMatrix__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Camera_getViewMatrix__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Camera.getViewMatrix", 
    "    Ogre::Matrix4 const & Camera.getViewMatrix()\n"
    "    Ogre::Matrix4 const & Camera.getViewMatrix(bool ownFrustumOnly)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setUseRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setUseRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseRenderingDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseRenderingDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getUseRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getUseRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (bool)((Ogre::Camera const *)arg1)->getUseRenderingDistance();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_synchroniseBaseSettingsWith(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","synchroniseBaseSettingsWith", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","synchroniseBaseSettingsWith", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->synchroniseBaseSettingsWith((Ogre::Camera const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getPositionForViewUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getPositionForViewUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Camera const *)arg1)->getPositionForViewUpdate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getOrientationForViewUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getOrientationForViewUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::Camera const *)arg1)->getOrientationForViewUpdate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_setUseMinPixelSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","setUseMinPixelSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseMinPixelSize", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseMinPixelSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getUseMinPixelSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getUseMinPixelSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (bool)((Ogre::Camera const *)arg1)->getUseMinPixelSize();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Camera_getPixelDisplayRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 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_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera const *","getPixelDisplayRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  result = (Ogre::Real)((Ogre::Camera const *)arg1)->getPixelDisplayRatio();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassCodec;

SWIGINTERN void
free_Ogre_Codec(Ogre::Codec *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Codec_registerCodec(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec *","Ogre::Codec::registerCodec", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  Ogre::Codec::registerCodec(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_isCodecRegistered(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool 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( "", "Ogre::String const &","Ogre::Codec::isCodecRegistered", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Codec::isCodecRegistered", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (bool)Ogre::Codec::isCodecRegistered((std::string const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_unRegisterCodec(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec *","Ogre::Codec::unRegisterCodec", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  Ogre::Codec::unRegisterCodec(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_getCodecIterator(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::Codec *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::Codec * >,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = Ogre::Codec::getCodecIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Codec::CodecIterator(static_cast< const Ogre::Codec::CodecIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_getExtensions(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = Ogre::Codec::getExtensions();
  vresult = SWIG_NewPointerObj((new Ogre::StringVector(static_cast< const Ogre::StringVector& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_getCodec__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Codec *result = 0 ;
  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( "", "Ogre::String const &","Ogre::Codec::getCodec", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Codec::getCodec", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Codec *)Ogre::Codec::getCodec((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Codec, 0 |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_getCodec__SWIG_1(int argc, VALUE *argv, VALUE self) {
  char *arg1 = (char *) 0 ;
  size_t arg2 ;
  int res1 ;
  char *buf1 = 0 ;
  int alloc1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Codec *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_AsCharPtrAndSize(argv[0], &buf1, NULL, &alloc1);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "char *","Ogre::Codec::getCodec", 1, argv[0] ));
  }
  arg1 = reinterpret_cast< char * >(buf1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::Codec::getCodec", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Codec *)Ogre::Codec::getCodec(arg1,arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Codec, 0 |  0 );
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return vresult;
fail:
  if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Codec_getCodec(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Codec_getCodec__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsCharPtrAndSize(argv[0], 0, NULL, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Codec_getCodec__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Codec.getCodec", 
    "    Ogre::Codec * Codec.getCodec(Ogre::String const &extension)\n"
    "    Ogre::Codec * Codec.getCodec(char *magicNumberPtr, size_t maxbytes)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_code(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  Ogre::MemoryDataStreamPtr *arg2 = 0 ;
  Ogre::Codec::CodecDataPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec const *","code", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MemoryDataStreamPtr &","code", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MemoryDataStreamPtr &","code", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MemoryDataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__CodecData_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Codec::CodecDataPtr &","code", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Codec::CodecDataPtr &","code", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Codec::CodecDataPtr * >(argp3);
  result = ((Ogre::Codec const *)arg1)->code(*arg2,*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_codeToFile(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  Ogre::MemoryDataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Codec::CodecDataPtr *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec const *","codeToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MemoryDataStreamPtr &","codeToFile", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MemoryDataStreamPtr &","codeToFile", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MemoryDataStreamPtr * >(argp2);
  {
    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 &","codeToFile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","codeToFile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__CodecData_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Codec::CodecDataPtr &","codeToFile", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Codec::CodecDataPtr &","codeToFile", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Codec::CodecDataPtr * >(argp4);
  ((Ogre::Codec const *)arg1)->codeToFile(*arg2,(Ogre::String const &)*arg3,*arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_decode(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::MemoryDataStream >,Ogre::SharedPtr< Ogre::Codec::CodecData > > > 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_Ogre__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec const *","decode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","decode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","decode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = ((Ogre::Codec const *)arg1)->decode(*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Codec::DecodeResult(static_cast< const Ogre::Codec::DecodeResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  result = ((Ogre::Codec const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_getDataType(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec const *","getDataType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  result = ((Ogre::Codec const *)arg1)->getDataType();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_magicNumberMatch(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec const *","magicNumberMatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","magicNumberMatch", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","magicNumberMatch", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (bool)((Ogre::Codec const *)arg1)->magicNumberMatch((char const *)arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Codec_magicNumberToFileExt(int argc, VALUE *argv, VALUE self) {
  Ogre::Codec *arg1 = (Ogre::Codec *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_Ogre__Codec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Codec const *","magicNumberToFileExt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Codec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","magicNumberToFileExt", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","magicNumberToFileExt", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = ((Ogre::Codec const *)arg1)->magicNumberToFileExt((char const *)arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


swig_class SwigClassPixelBox;

SWIGINTERN VALUE
_wrap_new_PixelBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PixelBox";
  Ogre::PixelBox *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PixelBox *)new Ogre::PixelBox();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PixelBox(Ogre::PixelBox *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_new_PixelBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = 0 ;
  Ogre::PixelFormat arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  const char *classname SWIGUNUSED = "Ogre::PixelBox";
  Ogre::PixelBox *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box const &","Ogre::PixelBox", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Box const &","Ogre::PixelBox", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelBox", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","Ogre::PixelBox", 3, argv[2] )); 
  }
  result = (Ogre::PixelBox *)new Ogre::PixelBox((Ogre::Box const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_PixelBox__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Box *arg1 = 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PixelBox";
  Ogre::PixelBox *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__Box,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Box const &","Ogre::PixelBox", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Box const &","Ogre::PixelBox", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Box * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelBox", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  result = (Ogre::PixelBox *)new Ogre::PixelBox((Ogre::Box const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_PixelBox__SWIG_3(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::PixelFormat arg4 ;
  void *arg5 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  const char *classname SWIGUNUSED = "Ogre::PixelBox";
  Ogre::PixelBox *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::PixelBox", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::PixelBox", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::PixelBox", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelBox", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  res5 = SWIG_ConvertPtr(argv[4],SWIG_as_voidptrptr(&arg5), 0, 0);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "void *","Ogre::PixelBox", 5, argv[4] )); 
  }
  result = (Ogre::PixelBox *)new Ogre::PixelBox(arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PixelBox__SWIG_4(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::PixelFormat arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PixelBox";
  Ogre::PixelBox *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::PixelBox", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::PixelBox", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::PixelBox", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelBox", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  result = (Ogre::PixelBox *)new Ogre::PixelBox(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PixelBox(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_PixelBox__SWIG_0(nargs, args, self);
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Box, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_PixelBox__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Box, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_PixelBox__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _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_size_t(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_PixelBox__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *ptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &ptr, 0, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_new_PixelBox__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PixelBox.new", 
    "    PixelBox.new()\n"
    "    PixelBox.new(Ogre::Box const &extents, Ogre::PixelFormat pixelFormat, void *pixelData)\n"
    "    PixelBox.new(Ogre::Box const &extents, Ogre::PixelFormat pixelFormat)\n"
    "    PixelBox.new(size_t width, size_t height, size_t depth, Ogre::PixelFormat pixelFormat, void *pixelData)\n"
    "    PixelBox.new(size_t width, size_t height, size_t depth, Ogre::PixelFormat pixelFormat)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_data_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","data", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","data", 2, argv[0] )); 
  }
  if (arg1) (arg1)->data = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_data_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","data", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result = (void *) ((arg1)->data);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_format_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","format", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","format", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  if (arg1) (arg1)->format = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_format_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","format", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result = (Ogre::PixelFormat) ((arg1)->format);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_rowPitch_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","rowPitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","rowPitch", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->rowPitch = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_rowPitch_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","rowPitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result =  ((arg1)->rowPitch);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_slicePitch_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","slicePitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","slicePitch", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->slicePitch = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_slicePitch_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","slicePitch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result =  ((arg1)->slicePitch);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_setConsecutive(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","setConsecutive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  (arg1)->setConsecutive();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_getRowSkip(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const *","getRowSkip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result = ((Ogre::PixelBox const *)arg1)->getRowSkip();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_getSliceSkip(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const *","getSliceSkip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result = ((Ogre::PixelBox const *)arg1)->getSliceSkip();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_isConsecutive(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const *","isConsecutive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result = (bool)((Ogre::PixelBox const *)arg1)->isConsecutive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_getConsecutiveSize(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const *","getConsecutiveSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  result = ((Ogre::PixelBox const *)arg1)->getConsecutiveSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_getSubVolume(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  Ogre::Box *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::PixelBox 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const *","getSubVolume", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Box const &","getSubVolume", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Box const &","getSubVolume", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Box * >(argp2);
  result = ((Ogre::PixelBox const *)arg1)->getSubVolume((Ogre::Box const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_getColourAt(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::ColourValue 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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","getColourAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getColourAt", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getColourAt", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","getColourAt", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  result = (arg1)->getColourAt(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelBox_setColourAt(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = (Ogre::PixelBox *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox *","setColourAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourAt", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourAt", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setColourAt", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setColourAt", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","setColourAt", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->setColourAt((Ogre::ColourValue const &)*arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPixelUtil;

SWIGINTERN VALUE
_wrap_PixelUtil_getNumElemBytes(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getNumElemBytes", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = Ogre::PixelUtil::getNumElemBytes(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getNumElemBits(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getNumElemBits", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = Ogre::PixelUtil::getNumElemBits(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getMemorySize(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::PixelFormat arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::PixelUtil::getMemorySize", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::PixelUtil::getMemorySize", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::PixelUtil::getMemorySize", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::getMemorySize", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  result = Ogre::PixelUtil::getMemorySize(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getFlags", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (unsigned int)Ogre::PixelUtil::getFlags(arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_hasAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::hasAlpha", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (bool)Ogre::PixelUtil::hasAlpha(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_isFloatingPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::isFloatingPoint", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (bool)Ogre::PixelUtil::isFloatingPoint(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_isCompressed(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::isCompressed", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (bool)Ogre::PixelUtil::isCompressed(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_isDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::isDepth", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (bool)Ogre::PixelUtil::isDepth(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_isNativeEndian(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::isNativeEndian", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (bool)Ogre::PixelUtil::isNativeEndian(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_isLuminance(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::isLuminance", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (bool)Ogre::PixelUtil::isLuminance(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_isValidExtent(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::PixelFormat arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::PixelUtil::isValidExtent", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::PixelUtil::isValidExtent", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::PixelUtil::isValidExtent", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::isValidExtent", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  result = (bool)Ogre::PixelUtil::isValidExtent(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getBitDepths(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int *arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getBitDepths", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int [4]","Ogre::PixelUtil::getBitDepths", 2, argv[1] )); 
  } 
  arg2 = reinterpret_cast< int * >(argp2);
  Ogre::PixelUtil::getBitDepths(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getBitMasks(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  Ogre::uint32 *arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getBitMasks", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uint32 [4]","Ogre::PixelUtil::getBitMasks", 2, argv[1] )); 
  } 
  arg2 = reinterpret_cast< Ogre::uint32 * >(argp2);
  Ogre::PixelUtil::getBitMasks(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getBitShifts(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  unsigned char *arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getBitShifts", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned char [4]","Ogre::PixelUtil::getBitShifts", 2, argv[1] )); 
  } 
  arg2 = reinterpret_cast< unsigned char * >(argp2);
  Ogre::PixelUtil::getBitShifts(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getFormatName(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getFormatName", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = Ogre::PixelUtil::getFormatName(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_isAccessible(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::isAccessible", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (bool)Ogre::PixelUtil::isAccessible(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getComponentType(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Ogre::PixelComponentType result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getComponentType", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = (Ogre::PixelComponentType)Ogre::PixelUtil::getComponentType(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getComponentCount(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getComponentCount", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  result = Ogre::PixelUtil::getComponentCount(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getFormatFromName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::PixelFormat result;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::PixelUtil::getFormatFromName", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PixelUtil::getFormatFromName", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::PixelUtil::getFormatFromName", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::PixelUtil::getFormatFromName", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatFromName((std::string const &)*arg1,arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getFormatFromName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::PixelFormat result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::PixelUtil::getFormatFromName", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PixelUtil::getFormatFromName", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::PixelUtil::getFormatFromName", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatFromName((std::string const &)*arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getFormatFromName__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::PixelFormat 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( "", "Ogre::String const &","Ogre::PixelUtil::getFormatFromName", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PixelUtil::getFormatFromName", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatFromName((std::string const &)*arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_getFormatFromName(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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PixelUtil_getFormatFromName__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PixelUtil_getFormatFromName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PixelUtil_getFormatFromName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PixelUtil.getFormatFromName", 
    "    Ogre::PixelFormat PixelUtil.getFormatFromName(Ogre::String const &name, bool accessibleOnly, bool caseSensitive)\n"
    "    Ogre::PixelFormat PixelUtil.getFormatFromName(Ogre::String const &name, bool accessibleOnly)\n"
    "    Ogre::PixelFormat PixelUtil.getFormatFromName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getBNFExpressionOfPixelFormats__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::PixelUtil::getBNFExpressionOfPixelFormats", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = Ogre::PixelUtil::getBNFExpressionOfPixelFormats(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getBNFExpressionOfPixelFormats__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = Ogre::PixelUtil::getBNFExpressionOfPixelFormats();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_getBNFExpressionOfPixelFormats(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_PixelUtil_getBNFExpressionOfPixelFormats__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_PixelUtil_getBNFExpressionOfPixelFormats__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PixelUtil.getBNFExpressionOfPixelFormats", 
    "    Ogre::String PixelUtil.getBNFExpressionOfPixelFormats(bool accessibleOnly)\n"
    "    Ogre::String PixelUtil.getBNFExpressionOfPixelFormats()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_getFormatForBitDepths(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelFormat arg1 ;
  Ogre::ushort arg2 ;
  Ogre::ushort arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::PixelFormat 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( "", "Ogre::PixelFormat","Ogre::PixelUtil::getFormatForBitDepths", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PixelFormat >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","Ogre::PixelUtil::getFormatForBitDepths", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","Ogre::PixelUtil::getFormatForBitDepths", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  result = (Ogre::PixelFormat)Ogre::PixelUtil::getFormatForBitDepths(arg1,arg2,arg3);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_packColour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = 0 ;
  Ogre::PixelFormat arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","Ogre::PixelUtil::packColour", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","Ogre::PixelUtil::packColour", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::packColour", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","Ogre::PixelUtil::packColour", 3, argv[2] )); 
  }
  Ogre::PixelUtil::packColour((Ogre::ColourValue const &)*arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_packColour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::uint8 arg1 ;
  Ogre::uint8 arg2 ;
  Ogre::uint8 arg3 ;
  Ogre::uint8 arg4 ;
  Ogre::PixelFormat arg5 ;
  void *arg6 = (void *) 0 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::PixelUtil::packColour", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint8 >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::PixelUtil::packColour", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::PixelUtil::packColour", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::PixelUtil::packColour", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::uint8 >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::packColour", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","Ogre::PixelUtil::packColour", 6, argv[5] )); 
  }
  Ogre::PixelUtil::packColour(arg1,arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_packColour__SWIG_2(int argc, VALUE *argv, VALUE self) {
  float arg1 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  Ogre::PixelFormat arg5 ;
  void *arg6 = (void *) 0 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  
  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( "", "float","Ogre::PixelUtil::packColour", 1, argv[0] ));
  } 
  arg1 = static_cast< float >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","Ogre::PixelUtil::packColour", 2, argv[1] ));
  } 
  arg2 = static_cast< float >(val2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","Ogre::PixelUtil::packColour", 3, argv[2] ));
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","Ogre::PixelUtil::packColour", 4, argv[3] ));
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::packColour", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void *","Ogre::PixelUtil::packColour", 6, argv[5] )); 
  }
  Ogre::PixelUtil::packColour(arg1,arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_packColour(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PixelUtil_packColour__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *ptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_PixelUtil_packColour__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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *ptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_PixelUtil_packColour__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "PixelUtil.packColour", 
    "    void PixelUtil.packColour(Ogre::ColourValue const &colour, Ogre::PixelFormat const pf, void *dest)\n"
    "    void PixelUtil.packColour(Ogre::uint8 const r, Ogre::uint8 const g, Ogre::uint8 const b, Ogre::uint8 const a, Ogre::PixelFormat const pf, void *dest)\n"
    "    void PixelUtil.packColour(float const r, float const g, float const b, float const a, Ogre::PixelFormat const pf, void *dest)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_unpackColour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = (Ogre::ColourValue *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue *","Ogre::PixelUtil::unpackColour", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::unpackColour", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void const *","Ogre::PixelUtil::unpackColour", 3, argv[2] )); 
  }
  Ogre::PixelUtil::unpackColour(arg1,arg2,(void const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_unpackColour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::uint8 *arg1 = (Ogre::uint8 *) 0 ;
  Ogre::uint8 *arg2 = (Ogre::uint8 *) 0 ;
  Ogre::uint8 *arg3 = (Ogre::uint8 *) 0 ;
  Ogre::uint8 *arg4 = (Ogre::uint8 *) 0 ;
  Ogre::PixelFormat arg5 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::uint8 *","Ogre::PixelUtil::unpackColour", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::uint8 * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uint8 *","Ogre::PixelUtil::unpackColour", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::uint8 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::uint8 *","Ogre::PixelUtil::unpackColour", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::uint8 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::uint8 *","Ogre::PixelUtil::unpackColour", 4, argv[3] )); 
  }
  arg4 = reinterpret_cast< Ogre::uint8 * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::unpackColour", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void const *","Ogre::PixelUtil::unpackColour", 6, argv[5] )); 
  }
  Ogre::PixelUtil::unpackColour(arg1,arg2,arg3,arg4,arg5,(void const *)arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_unpackColour__SWIG_2(int argc, VALUE *argv, VALUE self) {
  float *arg1 = (float *) 0 ;
  float *arg2 = (float *) 0 ;
  float *arg3 = (float *) 0 ;
  float *arg4 = (float *) 0 ;
  Ogre::PixelFormat arg5 ;
  void *arg6 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "float *","Ogre::PixelUtil::unpackColour", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< float * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float *","Ogre::PixelUtil::unpackColour", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float *","Ogre::PixelUtil::unpackColour", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(argv[3], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float *","Ogre::PixelUtil::unpackColour", 4, argv[3] )); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::unpackColour", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  res6 = SWIG_ConvertPtr(argv[5],SWIG_as_voidptrptr(&arg6), 0, 0);
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "void const *","Ogre::PixelUtil::unpackColour", 6, argv[5] )); 
  }
  Ogre::PixelUtil::unpackColour(arg1,arg2,arg3,arg4,arg5,(void const *)arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_unpackColour(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PixelUtil_unpackColour__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_unsigned_char, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_unsigned_char, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_unsigned_char, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *ptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_PixelUtil_unpackColour__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *ptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &ptr, 0, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_PixelUtil_unpackColour__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "PixelUtil.unpackColour", 
    "    void PixelUtil.unpackColour(Ogre::ColourValue *colour, Ogre::PixelFormat pf, void const *src)\n"
    "    void PixelUtil.unpackColour(Ogre::uint8 *r, Ogre::uint8 *g, Ogre::uint8 *b, Ogre::uint8 *a, Ogre::PixelFormat pf, void const *src)\n"
    "    void PixelUtil.unpackColour(float *r, float *g, float *b, float *a, Ogre::PixelFormat pf, void const *src)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_bulkPixelConversion__SWIG_0(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *arg3 = (void *) 0 ;
  Ogre::PixelFormat arg4 ;
  unsigned int arg5 ;
  int res1 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::PixelUtil::bulkPixelConversion", 1, argv[0] )); 
  }
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::bulkPixelConversion", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  res3 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","Ogre::PixelUtil::bulkPixelConversion", 3, argv[2] )); 
  }
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::PixelUtil::bulkPixelConversion", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(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","Ogre::PixelUtil::bulkPixelConversion", 5, argv[4] ));
  } 
  arg5 = static_cast< unsigned int >(val5);
  Ogre::PixelUtil::bulkPixelConversion(arg1,arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelUtil_bulkPixelConversion__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__PixelBox,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","Ogre::PixelUtil::bulkPixelConversion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","Ogre::PixelUtil::bulkPixelConversion", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","Ogre::PixelUtil::bulkPixelConversion", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","Ogre::PixelUtil::bulkPixelConversion", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  Ogre::PixelUtil::bulkPixelConversion((Ogre::PixelBox const &)*arg1,(Ogre::PixelBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelUtil_bulkPixelConversion(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PixelUtil_bulkPixelConversion__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *ptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &ptr, 0, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *ptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &ptr, 0, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_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_PixelUtil_bulkPixelConversion__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PixelUtil.bulkPixelConversion", 
    "    void PixelUtil.bulkPixelConversion(void *src, Ogre::PixelFormat srcFormat, void *dest, Ogre::PixelFormat dstFormat, unsigned int count)\n"
    "    void PixelUtil.bulkPixelConversion(Ogre::PixelBox const &src, Ogre::PixelBox const &dst)\n");
  
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PixelUtil(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PixelUtil";
  Ogre::PixelUtil *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PixelUtil *)new Ogre::PixelUtil();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PixelUtil(Ogre::PixelUtil *arg1) {
    delete arg1;
}

swig_class SwigClassImage;

SWIGINTERN VALUE
_wrap_new_Image__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Image";
  Ogre::Image *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Image *)new Ogre::Image();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Image__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Image";
  Ogre::Image *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__Image,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const &","Ogre::Image", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","Ogre::Image", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (Ogre::Image *)new Ogre::Image((Ogre::Image const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Image(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_Image__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Image__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Image.new", 
    "    Image.new()\n"
    "    Image.new(Ogre::Image const &img)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Image(Ogre::Image *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Image_flipAroundY(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","flipAroundY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (Ogre::Image *) &(arg1)->flipAroundY();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_flipAroundX(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","flipAroundX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (Ogre::Image *) &(arg1)->flipAroundX();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadDynamicImage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::uchar *arg2 = (Ogre::uchar *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  bool arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadDynamicImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uchar *","loadDynamicImage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::uchar * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadDynamicImage", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","loadDynamicImage", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadDynamicImage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::uchar *arg2 = (Ogre::uchar *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  bool arg7 ;
  size_t arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadDynamicImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uchar *","loadDynamicImage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::uchar * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadDynamicImage", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","loadDynamicImage", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadDynamicImage__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::uchar *arg2 = (Ogre::uchar *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadDynamicImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uchar *","loadDynamicImage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::uchar * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadDynamicImage", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","loadDynamicImage", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadDynamicImage__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::uchar *arg2 = (Ogre::uchar *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadDynamicImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uchar *","loadDynamicImage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::uchar * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadDynamicImage", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadDynamicImage__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::uchar *arg2 = (Ogre::uchar *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  Ogre::PixelFormat arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadDynamicImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uchar *","loadDynamicImage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::uchar * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadDynamicImage", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadDynamicImage", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  result = (Ogre::Image *) &(arg1)->loadDynamicImage(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_loadDynamicImage(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[10];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 10) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(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_Image_loadDynamicImage__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(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_Image_loadDynamicImage__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Image_loadDynamicImage__SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Image_loadDynamicImage__SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_unsigned_char, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_Image_loadDynamicImage__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "Image.loadDynamicImage", 
    "    Ogre::Image & Image.loadDynamicImage(Ogre::uchar *data, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, bool autoDelete, size_t numFaces, size_t numMipMaps)\n"
    "    Ogre::Image & Image.loadDynamicImage(Ogre::uchar *data, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, bool autoDelete, size_t numFaces)\n"
    "    Ogre::Image & Image.loadDynamicImage(Ogre::uchar *data, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, bool autoDelete)\n"
    "    Ogre::Image & Image.loadDynamicImage(Ogre::uchar *data, size_t width, size_t height, size_t depth, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.loadDynamicImage(Ogre::uchar *data, size_t width, size_t height, Ogre::PixelFormat format)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadRawData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadRawData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadRawData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","loadRawData", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","loadRawData", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadRawData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadRawData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadRawData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","loadRawData", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadRawData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadRawData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadRawData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadRawData__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  Ogre::PixelFormat arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","loadRawData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","loadRawData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  result = (Ogre::Image *) &(arg1)->loadRawData(*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_loadRawData(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 9) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(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_Image_loadRawData__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(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_Image_loadRawData__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Image_loadRawData__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_Image_loadRawData__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "Image.loadRawData", 
    "    Ogre::Image & Image.loadRawData(Ogre::DataStreamPtr &stream, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, size_t numFaces, size_t numMipMaps)\n"
    "    Ogre::Image & Image.loadRawData(Ogre::DataStreamPtr &stream, size_t width, size_t height, size_t depth, Ogre::PixelFormat format, size_t numFaces)\n"
    "    Ogre::Image & Image.loadRawData(Ogre::DataStreamPtr &stream, size_t width, size_t height, size_t depth, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.loadRawData(Ogre::DataStreamPtr &stream, size_t width, size_t height, Ogre::PixelFormat format)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Image *) &(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  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_Image_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Image *) &(arg1)->load(*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = (Ogre::Image *) &(arg1)->load(*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_load(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_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Image_load__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_Image_load__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 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_Image_load__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Image.load", 
    "    Ogre::Image & Image.load(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    Ogre::Image & Image.load(Ogre::DataStreamPtr &stream, Ogre::String const &type)\n"
    "    Ogre::Image & Image.load(Ogre::DataStreamPtr &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadTwoImagesAsRGBA__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::PixelFormat arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(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( "", "Ogre::String const &","loadTwoImagesAsRGBA", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 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 &","loadTwoImagesAsRGBA", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","loadTwoImagesAsRGBA", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadTwoImagesAsRGBA", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadTwoImagesAsRGBA__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(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( "", "Ogre::String const &","loadTwoImagesAsRGBA", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 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 &","loadTwoImagesAsRGBA", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","loadTwoImagesAsRGBA", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadTwoImagesAsRGBA__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::DataStreamPtr *arg3 = 0 ;
  Ogre::PixelFormat arg4 ;
  Ogre::String *arg5 = 0 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  int res6 = SWIG_OLDOBJ ;
  Ogre::Image *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::DataStreamPtr * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadTwoImagesAsRGBA", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","loadTwoImagesAsRGBA", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","loadTwoImagesAsRGBA", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3,arg4,(Ogre::String const &)*arg5,(Ogre::String const &)*arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return vresult;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadTwoImagesAsRGBA__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::DataStreamPtr *arg3 = 0 ;
  Ogre::PixelFormat arg4 ;
  Ogre::String *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::DataStreamPtr * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadTwoImagesAsRGBA", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","loadTwoImagesAsRGBA", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadTwoImagesAsRGBA", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3,arg4,(Ogre::String const &)*arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (SWIG_IsNewObj(res5)) delete arg5;
  return vresult;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadTwoImagesAsRGBA__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::DataStreamPtr *arg3 = 0 ;
  Ogre::PixelFormat arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::DataStreamPtr * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadTwoImagesAsRGBA", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_loadTwoImagesAsRGBA__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::DataStreamPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","loadTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadTwoImagesAsRGBA", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::DataStreamPtr * >(argp3);
  result = (Ogre::Image *) &(arg1)->loadTwoImagesAsRGBA(*arg2,*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_loadTwoImagesAsRGBA(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Image_loadTwoImagesAsRGBA__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Image_loadTwoImagesAsRGBA__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Image_loadTwoImagesAsRGBA__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Image_loadTwoImagesAsRGBA__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Image_loadTwoImagesAsRGBA__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Image_loadTwoImagesAsRGBA__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Image.loadTwoImagesAsRGBA", 
    "    Ogre::Image & Image.loadTwoImagesAsRGBA(Ogre::String const &rgbFilename, Ogre::String const &alphaFilename, Ogre::String const &groupName, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.loadTwoImagesAsRGBA(Ogre::String const &rgbFilename, Ogre::String const &alphaFilename, Ogre::String const &groupName)\n"
    "    Ogre::Image & Image.loadTwoImagesAsRGBA(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream, Ogre::PixelFormat, Ogre::String const &rgbType, Ogre::String const &alphaType)\n"
    "    Ogre::Image & Image.loadTwoImagesAsRGBA(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream, Ogre::PixelFormat, Ogre::String const &rgbType)\n"
    "    Ogre::Image & Image.loadTwoImagesAsRGBA(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream, Ogre::PixelFormat)\n"
    "    Ogre::Image & Image.loadTwoImagesAsRGBA(Ogre::DataStreamPtr &rgbStream, Ogre::DataStreamPtr &alphaStream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_combineTwoImagesAsRGBA__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::Image *arg2 = 0 ;
  Ogre::Image *arg3 = 0 ;
  Ogre::PixelFormat arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","combineTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image const &","combineTwoImagesAsRGBA", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","combineTwoImagesAsRGBA", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Image const &","combineTwoImagesAsRGBA", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","combineTwoImagesAsRGBA", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Image * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","combineTwoImagesAsRGBA", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  result = (Ogre::Image *) &(arg1)->combineTwoImagesAsRGBA((Ogre::Image const &)*arg2,(Ogre::Image const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_combineTwoImagesAsRGBA__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::Image *arg2 = 0 ;
  Ogre::Image *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Image *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","combineTwoImagesAsRGBA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image const &","combineTwoImagesAsRGBA", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","combineTwoImagesAsRGBA", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Image const &","combineTwoImagesAsRGBA", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","combineTwoImagesAsRGBA", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Image * >(argp3);
  result = (Ogre::Image *) &(arg1)->combineTwoImagesAsRGBA((Ogre::Image const &)*arg2,(Ogre::Image const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Image, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_combineTwoImagesAsRGBA(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_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Image, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Image, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Image_combineTwoImagesAsRGBA__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Image, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Image, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Image_combineTwoImagesAsRGBA__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Image.combineTwoImagesAsRGBA", 
    "    Ogre::Image & Image.combineTwoImagesAsRGBA(Ogre::Image const &rgb, Ogre::Image const &alpha, Ogre::PixelFormat format)\n"
    "    Ogre::Image & Image.combineTwoImagesAsRGBA(Ogre::Image const &rgb, Ogre::Image const &alpha)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_save(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(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( "", "Ogre::String const &","save", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","save", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->save((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_encode(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","encode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(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( "", "Ogre::String const &","encode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","encode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->encode((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uchar *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","getData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (Ogre::uchar *)(arg1)->getData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uchar *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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (Ogre::uchar *)((Ogre::Image const *)arg1)->getData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_unsigned_char, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_getData(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_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Image_getData__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Image_getData__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Image.getData", 
    "    Ogre::uchar const * Image.getData()\n"
    "    Ogre::uchar const * Image.getData()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getNumMipmaps(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getNumMipmaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getNumMipmaps();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_hasFlag(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::ImageFlags arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","hasFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ImageFlags","hasFlag", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ImageFlags >(val2);
  result = (bool)((Ogre::Image const *)arg1)->hasFlag(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getWidth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getHeight();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getDepth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getNumFaces(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getNumFaces", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getNumFaces();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getRowSpan(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getRowSpan", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getRowSpan();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::Image const *)arg1)->getFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getBPP(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uchar 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getBPP", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (Ogre::uchar)((Ogre::Image const *)arg1)->getBPP();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getHasAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getHasAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = (bool)((Ogre::Image const *)arg1)->getHasAlpha();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_applyGamma(int argc, VALUE *argv, VALUE self) {
  Ogre::uchar *arg1 = (Ogre::uchar *) 0 ;
  Ogre::Real arg2 ;
  size_t arg3 ;
  Ogre::uchar arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::uchar *","Ogre::Image::applyGamma", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::uchar * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Image::applyGamma", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::Image::applyGamma", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uchar","Ogre::Image::applyGamma", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::uchar >(val4);
  Ogre::Image::applyGamma(arg1,arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getColourAt(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  Ogre::ColourValue 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getColourAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getColourAt", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getColourAt", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","getColourAt", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  result = ((Ogre::Image const *)arg1)->getColourAt(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_setColourAt(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","setColourAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourAt", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourAt", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setColourAt", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setColourAt", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","setColourAt", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->setColourAt((Ogre::ColourValue const &)*arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getPixelBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::PixelBox 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getPixelBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getPixelBox", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getPixelBox", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = ((Ogre::Image const *)arg1)->getPixelBox(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getPixelBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::PixelBox 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getPixelBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getPixelBox", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::Image const *)arg1)->getPixelBox(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getPixelBox__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelBox 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image const *","getPixelBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  result = ((Ogre::Image const *)arg1)->getPixelBox();
  vresult = SWIG_NewPointerObj((new Ogre::PixelBox(static_cast< const Ogre::PixelBox& >(result))), SWIGTYPE_p_Ogre__PixelBox, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_getPixelBox(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_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Image_getPixelBox__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Image_getPixelBox__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Image_getPixelBox__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Image.getPixelBox", 
    "    Ogre::PixelBox Image.getPixelBox(size_t face, size_t mipmap)\n"
    "    Ogre::PixelBox Image.getPixelBox(size_t face)\n"
    "    Ogre::PixelBox Image.getPixelBox()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_freeMemory(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","freeMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  (arg1)->freeMemory();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_scale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  Ogre::Image::Filter arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","Ogre::Image::scale", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","Ogre::Image::scale", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","Ogre::Image::scale", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","Ogre::Image::scale", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Image::Filter","Ogre::Image::scale", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Image::Filter >(val3);
  Ogre::Image::scale((Ogre::PixelBox const &)*arg1,(Ogre::PixelBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_scale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelBox *arg1 = 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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__PixelBox,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","Ogre::Image::scale", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","Ogre::Image::scale", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::PixelBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","Ogre::Image::scale", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","Ogre::Image::scale", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  Ogre::Image::scale((Ogre::PixelBox const &)*arg1,(Ogre::PixelBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_scale(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Image_scale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Image_scale__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Image.scale", 
    "    void Image.scale(Ogre::PixelBox const &src, Ogre::PixelBox const &dst, Ogre::Image::Filter filter)\n"
    "    void Image.scale(Ogre::PixelBox const &src, Ogre::PixelBox const &dst)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::Image.resize

  call-seq:
    resize(width, height, filter=FILTER_BILINEAR)
    resize(width, height)

Resize the size of the Image.
*/
SWIGINTERN VALUE
_wrap_Image_resize__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::ushort arg3 ;
  Ogre::Image::Filter arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","resize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","resize", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Image::Filter","resize", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Image::Filter >(val4);
  (arg1)->resize(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_resize__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Image *arg1 = (Ogre::Image *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Image *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Image * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","resize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","resize", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->resize(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Image_resize(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_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Image_resize__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Image, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(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_Image_resize__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Image.resize", 
    "    void Image.resize(Ogre::ushort width, Ogre::ushort height, Ogre::Image::Filter filter)\n"
    "    void Image.resize(Ogre::ushort width, Ogre::ushort height)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_calculateSize(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::Image::calculateSize", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::Image::calculateSize", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::Image::calculateSize", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::Image::calculateSize", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","Ogre::Image::calculateSize", 5, argv[4] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::Image::calculateSize", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  result = Ogre::Image::calculateSize(arg1,arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Image_getFileExtFromMagic(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","Ogre::Image::getFileExtFromMagic", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","Ogre::Image::getFileExtFromMagic", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp1));
    }
  }
  result = Ogre::Image::getFileExtFromMagic(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassTexture;

SWIGINTERN VALUE
_wrap_Texture_setTextureType(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::TextureType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setTextureType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureType","setTextureType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureType >(val2);
  (arg1)->setTextureType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getTextureType(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureType 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getTextureType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::TextureType)((Ogre::Texture const *)arg1)->getTextureType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getNumMipmaps(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getNumMipmaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getNumMipmaps();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setNumMipmaps(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setNumMipmaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setNumMipmaps", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setNumMipmaps(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getMipmapsHardwareGenerated(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getMipmapsHardwareGenerated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (bool)((Ogre::Texture const *)arg1)->getMipmapsHardwareGenerated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getGamma(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getGamma", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (float)((Ogre::Texture const *)arg1)->getGamma();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setGamma(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setGamma", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setGamma", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setGamma(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setHardwareGammaEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setHardwareGammaEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setHardwareGammaEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setHardwareGammaEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_isHardwareGammaEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","isHardwareGammaEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (bool)((Ogre::Texture const *)arg1)->isHardwareGammaEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setFSAA(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::uint arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setFSAA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint","setFSAA", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint >(val2);
  {
    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 &","setFSAA", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFSAA", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setFSAA(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getFSAA(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getFSAA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::uint)((Ogre::Texture const *)arg1)->getFSAA();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getFSAAHint(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getFSAAHint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::String *) &((Ogre::Texture const *)arg1)->getFSAAHint();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getHeight();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getWidth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getDepth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getSrcHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getSrcHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getSrcHeight();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getSrcWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getSrcWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getSrcWidth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getSrcDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getSrcDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getSrcDepth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDepth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (int)((Ogre::Texture const *)arg1)->getUsage();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setUsage(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setUsage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setUsage", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setUsage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_createInternalResources(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","createInternalResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  (arg1)->createInternalResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_freeInternalResources(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","freeInternalResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  (arg1)->freeInternalResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_copyToTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::TexturePtr *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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","copyToTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TexturePtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TexturePtr &","copyToTexture", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr &","copyToTexture", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TexturePtr * >(argp2);
  (arg1)->copyToTexture(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_loadImage(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::Image *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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image * >(argp2);
  (arg1)->loadImage((Ogre::Image const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_loadRawData(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::ushort arg3 ;
  Ogre::ushort arg4 ;
  Ogre::PixelFormat arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::ushort >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  (arg1)->loadRawData(*arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture__loadImages(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::ConstImagePtrList *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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","_loadImages", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Image_const_p_Ogre__STLAllocatorT_Ogre__Image_const_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ConstImagePtrList const &","_loadImages", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ConstImagePtrList const &","_loadImages", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ConstImagePtrList * >(argp2);
  (arg1)->_loadImages((Ogre::ConstImagePtrList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::Texture const *)arg1)->getFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getDesiredFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getDesiredFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::Texture const *)arg1)->getDesiredFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getSrcFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getSrcFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::Texture const *)arg1)->getSrcFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setFormat", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  (arg1)->setFormat(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_hasAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","hasAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (bool)((Ogre::Texture const *)arg1)->hasAlpha();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setDesiredIntegerBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setDesiredIntegerBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setDesiredIntegerBitDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setDesiredIntegerBitDepth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getDesiredIntegerBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getDesiredIntegerBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::ushort)((Ogre::Texture const *)arg1)->getDesiredIntegerBitDepth();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setDesiredFloatBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setDesiredFloatBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setDesiredFloatBitDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setDesiredFloatBitDepth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getDesiredFloatBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getDesiredFloatBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::ushort)((Ogre::Texture const *)arg1)->getDesiredFloatBitDepth();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setDesiredBitDepths(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setDesiredBitDepths", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setDesiredBitDepths", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setDesiredBitDepths", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setDesiredBitDepths(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_setTreatLuminanceAsAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","setTreatLuminanceAsAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTreatLuminanceAsAlpha", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTreatLuminanceAsAlpha(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getTreatLuminanceAsAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getTreatLuminanceAsAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (bool)((Ogre::Texture const *)arg1)->getTreatLuminanceAsAlpha();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getNumFaces(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture const *","getNumFaces", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = ((Ogre::Texture const *)arg1)->getNumFaces();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::HardwarePixelBufferSharedPtr 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","getBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->getBuffer(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::HardwarePixelBufferSharedPtr(static_cast< const Ogre::HardwarePixelBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::HardwarePixelBufferSharedPtr 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","getBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (arg1)->getBuffer(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::HardwarePixelBufferSharedPtr(static_cast< const Ogre::HardwarePixelBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getBuffer__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwarePixelBufferSharedPtr 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","getBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (arg1)->getBuffer();
  vresult = SWIG_NewPointerObj((new Ogre::HardwarePixelBufferSharedPtr(static_cast< const Ogre::HardwarePixelBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Texture_getBuffer(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_Ogre__Texture, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Texture_getBuffer__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Texture, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Texture_getBuffer__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Texture, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Texture_getBuffer__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Texture.getBuffer", 
    "    Ogre::HardwarePixelBufferSharedPtr Texture.getBuffer(size_t face, size_t mipmap)\n"
    "    Ogre::HardwarePixelBufferSharedPtr Texture.getBuffer(size_t face)\n"
    "    Ogre::HardwarePixelBufferSharedPtr Texture.getBuffer()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_convertToImage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::Image *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","convertToImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image &","convertToImage", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image &","convertToImage", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","convertToImage", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->convertToImage(*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_convertToImage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::Image *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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","convertToImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image &","convertToImage", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image &","convertToImage", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image * >(argp2);
  (arg1)->convertToImage(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Texture_convertToImage(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_Ogre__Texture, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Image, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Texture_convertToImage__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Texture, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Image, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Texture_convertToImage__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Texture.convertToImage", 
    "    void Texture.convertToImage(Ogre::Image &destImage, bool includeMipMaps)\n"
    "    void Texture.convertToImage(Ogre::Image &destImage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Texture_getCustomAttribute(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 ;
  
  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_Ogre__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","getCustomAttribute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(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( "", "Ogre::String const &","getCustomAttribute", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getCustomAttribute", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","getCustomAttribute", 3, argv[1] )); 
  }
  (arg1)->getCustomAttribute((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_Texture(Ogre::Texture *arg1) {
    delete arg1;
}

swig_class SwigClassTexturePtr;

SWIGINTERN VALUE
_wrap_new_TexturePtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TexturePtr";
  Ogre::TexturePtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TexturePtr *)new Ogre::TexturePtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TexturePtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Texture *arg1 = (Ogre::Texture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexturePtr";
  Ogre::TexturePtr *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__Texture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Texture *","Ogre::TexturePtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Texture * >(argp1);
  result = (Ogre::TexturePtr *)new Ogre::TexturePtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TexturePtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TexturePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexturePtr";
  Ogre::TexturePtr *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__TexturePtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TexturePtr const &","Ogre::TexturePtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr const &","Ogre::TexturePtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::TexturePtr * >(argp1);
  result = (Ogre::TexturePtr *)new Ogre::TexturePtr((Ogre::TexturePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TexturePtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexturePtr";
  Ogre::TexturePtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::TexturePtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::TexturePtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::TexturePtr *)new Ogre::TexturePtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TexturePtr(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_TexturePtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Texture, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TexturePtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TexturePtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TexturePtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TexturePtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "TexturePtr.new", 
    "    TexturePtr.new()\n"
    "    TexturePtr.new(Ogre::Texture *rep)\n"
    "    TexturePtr.new(Ogre::TexturePtr const &r)\n"
    "    TexturePtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_TexturePtr(Ogre::TexturePtr *arg1) {
    delete arg1;
}

swig_class SwigClassTextureUnitState;

SWIGINTERN VALUE
_wrap_new_TextureUnitState__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TextureUnitState";
  Ogre::TextureUnitState *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__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","Ogre::TextureUnitState", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TextureUnitState__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::TextureUnitState *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TextureUnitState";
  Ogre::TextureUnitState *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__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","Ogre::TextureUnitState", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__TextureUnitState,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const &","Ogre::TextureUnitState", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TextureUnitState const &","Ogre::TextureUnitState", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1,(Ogre::TextureUnitState const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextureUnitState(Ogre::TextureUnitState *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_new_TextureUnitState__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TextureUnitState";
  Ogre::TextureUnitState *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","Ogre::TextureUnitState", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::TextureUnitState", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::TextureUnitState", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","Ogre::TextureUnitState", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1,(Ogre::String const &)*arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TextureUnitState__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::TextureUnitState";
  Ogre::TextureUnitState *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__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","Ogre::TextureUnitState", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::TextureUnitState", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::TextureUnitState", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::TextureUnitState *)new Ogre::TextureUnitState(arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TextureUnitState(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TextureUnitState__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_TextureUnitState__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_new_TextureUnitState__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TextureUnitState__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TextureUnitState.new", 
    "    TextureUnitState.new(Ogre::Pass *parent)\n"
    "    TextureUnitState.new(Ogre::Pass *parent, Ogre::TextureUnitState const &oth)\n"
    "    TextureUnitState.new(Ogre::Pass *parent, Ogre::String const &texName, unsigned int texCoordSet)\n"
    "    TextureUnitState.new(Ogre::Pass *parent, Ogre::String const &texName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getTextureName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::TextureType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureType","setTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureType >(val3);
  (arg1)->setTextureName((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setTextureName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setTextureName(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_Ogre__TextureUnitState, 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_TextureUnitState_setTextureName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState_setTextureName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.setTextureName", 
    "    void TextureUnitState.setTextureName(Ogre::String const &name, Ogre::TextureType ttype)\n"
    "    void TextureUnitState.setTextureName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TexturePtr *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TexturePtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TexturePtr const &","setTexture", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr const &","setTexture", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TexturePtr * >(argp2);
  (arg1)->setTexture((Ogre::TexturePtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCubicTextureName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCubicTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setCubicTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCubicTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setCubicTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setCubicTextureName((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCubicTextureName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCubicTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setCubicTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCubicTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setCubicTextureName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCubicTextureName__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = (Ogre::String *) (Ogre::String *)0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCubicTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const *const","setCubicTextureName", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setCubicTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setCubicTextureName((Ogre::String const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCubicTextureName__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = (Ogre::String *) (Ogre::String *)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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCubicTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const *const","setCubicTextureName", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  (arg1)->setCubicTextureName((Ogre::String const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setCubicTextureName(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_Ogre__TextureUnitState, 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_TextureUnitState_setCubicTextureName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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_TextureUnitState_setCubicTextureName__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState_setCubicTextureName__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState_setCubicTextureName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.setCubicTextureName", 
    "    void TextureUnitState.setCubicTextureName(Ogre::String const &name, bool forUVW)\n"
    "    void TextureUnitState.setCubicTextureName(Ogre::String const &name)\n"
    "    void TextureUnitState.setCubicTextureName(Ogre::String const *const names, bool forUVW)\n"
    "    void TextureUnitState.setCubicTextureName(Ogre::String const *const names)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCubicTexture__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TexturePtr *arg2 = (Ogre::TexturePtr *) (Ogre::TexturePtr *)0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCubicTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TexturePtr const *const","setCubicTexture", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TexturePtr * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setCubicTexture", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setCubicTexture((Ogre::TexturePtr const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCubicTexture__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TexturePtr *arg2 = (Ogre::TexturePtr *) (Ogre::TexturePtr *)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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCubicTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TexturePtr const *const","setCubicTexture", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TexturePtr * >(argp2);
  (arg1)->setCubicTexture((Ogre::TexturePtr const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setCubicTexture(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TexturePtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TextureUnitState_setCubicTexture__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TexturePtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState_setCubicTexture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.setCubicTexture", 
    "    void TextureUnitState.setCubicTexture(Ogre::TexturePtr const *const texPtrs, bool forUVW)\n"
    "    void TextureUnitState.setCubicTexture(Ogre::TexturePtr const *const texPtrs)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAnimatedTextureName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAnimatedTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setAnimatedTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setAnimatedTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","setAnimatedTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setAnimatedTextureName", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setAnimatedTextureName((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAnimatedTextureName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAnimatedTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setAnimatedTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setAnimatedTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","setAnimatedTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->setAnimatedTextureName((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAnimatedTextureName__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = (Ogre::String *) (Ogre::String *)0 ;
  unsigned int arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAnimatedTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const *const","setAnimatedTextureName", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","setAnimatedTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setAnimatedTextureName", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setAnimatedTextureName((Ogre::String const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAnimatedTextureName__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = (Ogre::String *) (Ogre::String *)0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAnimatedTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const *const","setAnimatedTextureName", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","setAnimatedTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->setAnimatedTextureName((Ogre::String const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setAnimatedTextureName(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_Ogre__TextureUnitState, 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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState_setAnimatedTextureName__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState_setAnimatedTextureName__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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_AsVal_unsigned_SS_int(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_TextureUnitState_setAnimatedTextureName__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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_AsVal_unsigned_SS_int(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_TextureUnitState_setAnimatedTextureName__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.setAnimatedTextureName", 
    "    void TextureUnitState.setAnimatedTextureName(Ogre::String const &name, unsigned int numFrames, Ogre::Real duration)\n"
    "    void TextureUnitState.setAnimatedTextureName(Ogre::String const &name, unsigned int numFrames)\n"
    "    void TextureUnitState.setAnimatedTextureName(Ogre::String const *const names, unsigned int numFrames, Ogre::Real duration)\n"
    "    void TextureUnitState.setAnimatedTextureName(Ogre::String const *const names, unsigned int numFrames)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureDimensions__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< std::pair< size_t,size_t > > 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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","getTextureDimensions", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = ((Ogre::TextureUnitState const *)arg1)->getTextureDimensions(arg2);
  vresult = SWIG_NewPointerObj((new std::pair< size_t,size_t >(static_cast< const std::pair< size_t,size_t >& >(result))), SWIGTYPE_p_std__pairT_size_t_size_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureDimensions__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< std::pair< size_t,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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = ((Ogre::TextureUnitState const *)arg1)->getTextureDimensions();
  vresult = SWIG_NewPointerObj((new std::pair< size_t,size_t >(static_cast< const std::pair< size_t,size_t >& >(result))), SWIGTYPE_p_std__pairT_size_t_size_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_getTextureDimensions(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TextureUnitState_getTextureDimensions__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState_getTextureDimensions__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TextureUnitState.getTextureDimensions", 
    "    std::pair< size_t,size_t > TextureUnitState.getTextureDimensions(unsigned int frame)\n"
    "    std::pair< size_t,size_t > TextureUnitState.getTextureDimensions()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCurrentFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCurrentFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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","setCurrentFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setCurrentFrame(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getCurrentFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getCurrentFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getCurrentFrame();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getFrameTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::String *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getFrameTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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","getFrameTextureName", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getFrameTextureName(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setFrameTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setFrameTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setFrameTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFrameTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","setFrameTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->setFrameTextureName((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_addFrameTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","addFrameTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","addFrameTextureName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addFrameTextureName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addFrameTextureName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_deleteFrameTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","deleteFrameTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","deleteFrameTextureName", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->deleteFrameTextureName(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getNumFrames(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getNumFrames", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getNumFrames();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setBindingType(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::BindingType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setBindingType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::BindingType","setBindingType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::BindingType >(val2);
  (arg1)->setBindingType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getBindingType(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureUnitState::BindingType 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getBindingType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TextureUnitState::BindingType)((Ogre::TextureUnitState const *)arg1)->getBindingType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setContentType(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::ContentType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setContentType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::ContentType","setContentType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::ContentType >(val2);
  (arg1)->setContentType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getContentType(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureUnitState::ContentType 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getContentType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TextureUnitState::ContentType)((Ogre::TextureUnitState const *)arg1)->getContentType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_isCubic(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","isCubic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->isCubic();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_is3D(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","is3D", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->is3D();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureType(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureType 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TextureType)((Ogre::TextureUnitState const *)arg1)->getTextureType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setDesiredFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setDesiredFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setDesiredFormat", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  (arg1)->setDesiredFormat(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getDesiredFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getDesiredFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::TextureUnitState const *)arg1)->getDesiredFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setNumMipmaps(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setNumMipmaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setNumMipmaps", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setNumMipmaps(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getNumMipmaps(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getNumMipmaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (int)((Ogre::TextureUnitState const *)arg1)->getNumMipmaps();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setIsAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setIsAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setIsAlpha", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setIsAlpha(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getIsAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getIsAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->getIsAlpha();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setHardwareGammaEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setHardwareGammaEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setHardwareGammaEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setHardwareGammaEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_isHardwareGammaEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","isHardwareGammaEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->isHardwareGammaEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureCoordSet(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getTextureCoordSet();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureCoordSet(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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","setTextureCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setTextureCoordSet(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Matrix4 *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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 &","setTextureTransform", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","setTextureTransform", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->setTextureTransform((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::TextureUnitState const *)arg1)->getTextureTransform();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureScroll(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureScroll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTextureScroll", 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","setTextureScroll", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setTextureScroll(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureUScroll(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureUScroll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTextureUScroll", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTextureUScroll(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureUScroll(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureUScroll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureUScroll();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureVScroll(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureVScroll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTextureVScroll", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTextureVScroll(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureVScroll(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureVScroll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureVScroll();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureUScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureUScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTextureUScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTextureUScale(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureUScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureUScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureUScale();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureVScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureVScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTextureVScale", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTextureVScale(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureVScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureVScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getTextureVScale();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTextureScale", 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","setTextureScale", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setTextureScale(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureRotate(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Radian *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureRotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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 const &","setTextureRotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setTextureRotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setTextureRotate((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureRotate(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureRotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Radian *) &((Ogre::TextureUnitState const *)arg1)->getTextureRotate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureAddressingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureUnitState::UVWAddressingMode *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureAddressingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TextureUnitState::UVWAddressingMode *) &((Ogre::TextureUnitState const *)arg1)->getTextureAddressingMode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState__UVWAddressingMode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureAddressingMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureAddressingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureAddressingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureAddressingMode","setTextureAddressingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureAddressingMode >(val2);
  (arg1)->setTextureAddressingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureAddressingMode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureAddressingMode arg2 ;
  Ogre::TextureUnitState::TextureAddressingMode arg3 ;
  Ogre::TextureUnitState::TextureAddressingMode arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureAddressingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureAddressingMode","setTextureAddressingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureAddressingMode >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureAddressingMode","setTextureAddressingMode", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureUnitState::TextureAddressingMode >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureAddressingMode","setTextureAddressingMode", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureUnitState::TextureAddressingMode >(val4);
  (arg1)->setTextureAddressingMode(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureAddressingMode__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::UVWAddressingMode *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureAddressingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TextureUnitState__UVWAddressingMode,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::UVWAddressingMode const &","setTextureAddressingMode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TextureUnitState::UVWAddressingMode const &","setTextureAddressingMode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState::UVWAddressingMode * >(argp2);
  (arg1)->setTextureAddressingMode((Ogre::TextureUnitState::UVWAddressingMode const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setTextureAddressingMode(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TextureUnitState__UVWAddressingMode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TextureUnitState_setTextureAddressingMode__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState_setTextureAddressingMode__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureUnitState_setTextureAddressingMode__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.setTextureAddressingMode", 
    "    void TextureUnitState.setTextureAddressingMode(Ogre::TextureUnitState::TextureAddressingMode tam)\n"
    "    void TextureUnitState.setTextureAddressingMode(Ogre::TextureUnitState::TextureAddressingMode u, Ogre::TextureUnitState::TextureAddressingMode v, Ogre::TextureUnitState::TextureAddressingMode w)\n"
    "    void TextureUnitState.setTextureAddressingMode(Ogre::TextureUnitState::UVWAddressingMode const &uvw)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureBorderColour(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::ColourValue *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureBorderColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setTextureBorderColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setTextureBorderColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setTextureBorderColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureBorderColour(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureBorderColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::TextureUnitState const *)arg1)->getTextureBorderColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOperationEx__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  Ogre::ColourValue *arg5 = 0 ;
  Ogre::ColourValue *arg6 = 0 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOperationEx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setColourOperationEx", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourOperationEx", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourOperationEx", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::ColourValue * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourOperationEx", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourOperationEx", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::ColourValue * >(argp6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setColourOperationEx", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setColourOperationEx(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5,(Ogre::ColourValue const &)*arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOperationEx__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  Ogre::ColourValue *arg5 = 0 ;
  Ogre::ColourValue *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOperationEx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setColourOperationEx", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourOperationEx", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourOperationEx", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::ColourValue * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourOperationEx", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourOperationEx", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::ColourValue * >(argp6);
  (arg1)->setColourOperationEx(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5,(Ogre::ColourValue const &)*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOperationEx__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  Ogre::ColourValue *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOperationEx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setColourOperationEx", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourOperationEx", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourOperationEx", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::ColourValue * >(argp5);
  (arg1)->setColourOperationEx(arg2,arg3,arg4,(Ogre::ColourValue const &)*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOperationEx__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOperationEx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setColourOperationEx", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  (arg1)->setColourOperationEx(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOperationEx__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOperationEx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setColourOperationEx", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setColourOperationEx", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  (arg1)->setColourOperationEx(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOperationEx__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOperationEx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setColourOperationEx", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  (arg1)->setColourOperationEx(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setColourOperationEx(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState_setColourOperationEx__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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_TextureUnitState_setColourOperationEx__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureUnitState_setColourOperationEx__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TextureUnitState_setColourOperationEx__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_TextureUnitState_setColourOperationEx__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureUnitState_setColourOperationEx__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "TextureUnitState.setColourOperationEx", 
    "    void TextureUnitState.setColourOperationEx(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::ColourValue const &arg1, Ogre::ColourValue const &arg2, Ogre::Real manualBlend)\n"
    "    void TextureUnitState.setColourOperationEx(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::ColourValue const &arg1, Ogre::ColourValue const &arg2)\n"
    "    void TextureUnitState.setColourOperationEx(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::ColourValue const &arg1)\n"
    "    void TextureUnitState.setColourOperationEx(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2)\n"
    "    void TextureUnitState.setColourOperationEx(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1)\n"
    "    void TextureUnitState.setColourOperationEx(Ogre::LayerBlendOperationEx op)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperation","setColourOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperation >(val2);
  (arg1)->setColourOperation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setColourOpMultipassFallback(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setColourOpMultipassFallback", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setColourOpMultipassFallback", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setColourOpMultipassFallback", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  (arg1)->setColourOpMultipassFallback(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getColourBlendMode(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LayerBlendModeEx *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getColourBlendMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::LayerBlendModeEx *) &((Ogre::TextureUnitState const *)arg1)->getColourBlendMode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LayerBlendModeEx, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getAlphaBlendMode(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LayerBlendModeEx *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getAlphaBlendMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::LayerBlendModeEx *) &((Ogre::TextureUnitState const *)arg1)->getAlphaBlendMode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LayerBlendModeEx, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getColourBlendFallbackSrc(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendFactor 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getColourBlendFallbackSrc", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::SceneBlendFactor)((Ogre::TextureUnitState const *)arg1)->getColourBlendFallbackSrc();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getColourBlendFallbackDest(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendFactor 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getColourBlendFallbackDest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::SceneBlendFactor)((Ogre::TextureUnitState const *)arg1)->getColourBlendFallbackDest();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAlphaOperation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAlphaOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setAlphaOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setAlphaOperation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setAlphaOperation", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setAlphaOperation", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setAlphaOperation(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAlphaOperation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAlphaOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setAlphaOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setAlphaOperation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setAlphaOperation", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setAlphaOperation(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAlphaOperation__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAlphaOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setAlphaOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setAlphaOperation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setAlphaOperation(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAlphaOperation__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  Ogre::LayerBlendSource arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAlphaOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setAlphaOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::LayerBlendSource >(val4);
  (arg1)->setAlphaOperation(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAlphaOperation__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  Ogre::LayerBlendSource arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAlphaOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setAlphaOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LayerBlendSource","setAlphaOperation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LayerBlendSource >(val3);
  (arg1)->setAlphaOperation(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setAlphaOperation__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::LayerBlendOperationEx arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setAlphaOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LayerBlendOperationEx","setAlphaOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LayerBlendOperationEx >(val2);
  (arg1)->setAlphaOperation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setAlphaOperation(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState_setAlphaOperation__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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_TextureUnitState_setAlphaOperation__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureUnitState_setAlphaOperation__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(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_TextureUnitState_setAlphaOperation__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TextureUnitState_setAlphaOperation__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureUnitState_setAlphaOperation__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "TextureUnitState.setAlphaOperation", 
    "    void TextureUnitState.setAlphaOperation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::Real arg1, Ogre::Real arg2, Ogre::Real manualBlend)\n"
    "    void TextureUnitState.setAlphaOperation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::Real arg1, Ogre::Real arg2)\n"
    "    void TextureUnitState.setAlphaOperation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2, Ogre::Real arg1)\n"
    "    void TextureUnitState.setAlphaOperation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1, Ogre::LayerBlendSource source2)\n"
    "    void TextureUnitState.setAlphaOperation(Ogre::LayerBlendOperationEx op, Ogre::LayerBlendSource source1)\n"
    "    void TextureUnitState.setAlphaOperation(Ogre::LayerBlendOperationEx op)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_addEffect(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureEffect *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","addEffect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TextureUnitState__TextureEffect,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureEffect &","addEffect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TextureUnitState::TextureEffect &","addEffect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState::TextureEffect * >(argp2);
  (arg1)->addEffect(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setEnvironmentMap__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  Ogre::TextureUnitState::EnvMapType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setEnvironmentMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnvironmentMap", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::EnvMapType","setEnvironmentMap", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureUnitState::EnvMapType >(val3);
  (arg1)->setEnvironmentMap(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setEnvironmentMap__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setEnvironmentMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnvironmentMap", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEnvironmentMap(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setEnvironmentMap(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState_setEnvironmentMap__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_TextureUnitState_setEnvironmentMap__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.setEnvironmentMap", 
    "    void TextureUnitState.setEnvironmentMap(bool enable, Ogre::TextureUnitState::EnvMapType envMapType)\n"
    "    void TextureUnitState.setEnvironmentMap(bool enable)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setScrollAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setScrollAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScrollAnimation", 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","setScrollAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setScrollAnimation(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setRotateAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setRotateAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRotateAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setRotateAnimation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTransformAnimation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg2 ;
  Ogre::WaveformType arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTransformAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","setTransformAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::WaveformType","setTransformAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::WaveformType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setTransformAnimation", 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","setTransformAnimation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setTransformAnimation", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setTransformAnimation", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setTransformAnimation(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTransformAnimation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg2 ;
  Ogre::WaveformType arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTransformAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","setTransformAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::WaveformType","setTransformAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::WaveformType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setTransformAnimation", 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","setTransformAnimation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setTransformAnimation", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setTransformAnimation(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTransformAnimation__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg2 ;
  Ogre::WaveformType arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTransformAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","setTransformAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::WaveformType","setTransformAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::WaveformType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setTransformAnimation", 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","setTransformAnimation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setTransformAnimation(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTransformAnimation__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg2 ;
  Ogre::WaveformType arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTransformAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","setTransformAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::WaveformType","setTransformAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::WaveformType >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setTransformAnimation", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setTransformAnimation(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTransformAnimation__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg2 ;
  Ogre::WaveformType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTransformAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","setTransformAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::WaveformType","setTransformAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::WaveformType >(val3);
  (arg1)->setTransformAnimation(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setTransformAnimation(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__TextureUnitState, 0);
    _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_TextureUnitState_setTransformAnimation__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureUnitState_setTransformAnimation__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            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_TextureUnitState_setTransformAnimation__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TextureUnitState_setTransformAnimation__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureUnitState_setTransformAnimation__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "TextureUnitState.setTransformAnimation", 
    "    void TextureUnitState.setTransformAnimation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase, Ogre::Real amplitude)\n"
    "    void TextureUnitState.setTransformAnimation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase)\n"
    "    void TextureUnitState.setTransformAnimation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base, Ogre::Real frequency)\n"
    "    void TextureUnitState.setTransformAnimation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType, Ogre::Real base)\n"
    "    void TextureUnitState.setTransformAnimation(Ogre::TextureUnitState::TextureTransformType const ttype, Ogre::WaveformType const waveType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setProjectiveTexturing__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  Ogre::Frustum *arg3 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setProjectiveTexturing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setProjectiveTexturing", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Frustum const *","setProjectiveTexturing", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Frustum * >(argp3);
  (arg1)->setProjectiveTexturing(arg2,(Ogre::Frustum const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setProjectiveTexturing__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setProjectiveTexturing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setProjectiveTexturing", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setProjectiveTexturing(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setProjectiveTexturing(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState_setProjectiveTexturing__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TextureUnitState_setProjectiveTexturing__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.setProjectiveTexturing", 
    "    void TextureUnitState.setProjectiveTexturing(bool enabled, Ogre::Frustum const *projectionSettings)\n"
    "    void TextureUnitState.setProjectiveTexturing(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_removeAllEffects(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","removeAllEffects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->removeAllEffects();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_removeEffect(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureEffectType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","removeEffect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureEffectType","removeEffect", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::TextureEffectType >(val2);
  (arg1)->removeEffect(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_isBlank(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","isBlank", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->isBlank();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setBlank(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setBlank", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->setBlank();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_isTextureLoadFailing(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","isTextureLoadFailing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->isTextureLoadFailing();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_retryTextureLoad(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","retryTextureLoad", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->retryTextureLoad();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getEffects(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureUnitState::EffectMap *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getEffects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TextureUnitState::EffectMap *) &((Ogre::TextureUnitState const *)arg1)->getEffects();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getAnimationDuration(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getAnimationDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Real)((Ogre::TextureUnitState const *)arg1)->getAnimationDuration();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureFiltering__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureFilterOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureFilterOptions","setTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureFilterOptions >(val2);
  (arg1)->setTextureFiltering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureFiltering__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::FilterType arg2 ;
  Ogre::FilterOptions arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FilterType","setTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FilterType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setTextureFiltering", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FilterOptions >(val3);
  (arg1)->setTextureFiltering(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureFiltering__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::FilterOptions arg2 ;
  Ogre::FilterOptions arg3 ;
  Ogre::FilterOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FilterOptions >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setTextureFiltering", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FilterOptions >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setTextureFiltering", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::FilterOptions >(val4);
  (arg1)->setTextureFiltering(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setTextureFiltering(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState_setTextureFiltering__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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_TextureUnitState_setTextureFiltering__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureUnitState_setTextureFiltering__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.setTextureFiltering", 
    "    void TextureUnitState.setTextureFiltering(Ogre::TextureFilterOptions filterType)\n"
    "    void TextureUnitState.setTextureFiltering(Ogre::FilterType ftype, Ogre::FilterOptions opts)\n"
    "    void TextureUnitState.setTextureFiltering(Ogre::FilterOptions minFilter, Ogre::FilterOptions magFilter, Ogre::FilterOptions mipFilter)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureFiltering(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::FilterType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::FilterOptions 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FilterType","getTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FilterType >(val2);
  result = (Ogre::FilterOptions)((Ogre::TextureUnitState const *)arg1)->getTextureFiltering(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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","setTextureAnisotropy", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setTextureAnisotropy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (unsigned int)((Ogre::TextureUnitState const *)arg1)->getTextureAnisotropy();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureMipmapBias(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureMipmapBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setTextureMipmapBias", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setTextureMipmapBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureMipmapBias(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureMipmapBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (float)((Ogre::TextureUnitState const *)arg1)->getTextureMipmapBias();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCompositorReference__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCompositorReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setCompositorReference", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCompositorReference", 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 &","setCompositorReference", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCompositorReference", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setCompositorReference", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setCompositorReference((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setCompositorReference__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setCompositorReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setCompositorReference", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCompositorReference", 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 &","setCompositorReference", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCompositorReference", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setCompositorReference((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_setCompositorReference(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_Ogre__TextureUnitState, 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_TextureUnitState_setCompositorReference__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 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) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureUnitState_setCompositorReference__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureUnitState.setCompositorReference", 
    "    void TextureUnitState.setCompositorReference(Ogre::String const &compositorName, Ogre::String const &textureName, size_t mrtIndex)\n"
    "    void TextureUnitState.setCompositorReference(Ogre::String const &compositorName, Ogre::String const &textureName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getReferencedCompositorName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getReferencedCompositorName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getReferencedCompositorName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getReferencedTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getReferencedTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getReferencedTextureName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getReferencedMRTIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getReferencedMRTIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = ((Ogre::TextureUnitState const *)arg1)->getReferencedMRTIndex();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pass *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Pass *)((Ogre::TextureUnitState const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__prepare(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->_prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->_unprepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__load(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->_load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__unload(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->_unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_hasViewRelativeTextureCoordinateGeneration(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","hasViewRelativeTextureCoordinateGeneration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->hasViewRelativeTextureCoordinateGeneration();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (bool)((Ogre::TextureUnitState const *)arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__notifyNeedsRecompile(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_notifyNeedsRecompile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  (arg1)->_notifyNeedsRecompile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_setTextureNameAlias(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","setTextureNameAlias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(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( "", "Ogre::String const &","setTextureNameAlias", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setTextureNameAlias", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setTextureNameAlias((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_getTextureNameAlias(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureNameAlias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::String *) &((Ogre::TextureUnitState const *)arg1)->getTextureNameAlias();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_applyTextureAliases__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","applyTextureAliases", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState_applyTextureAliases__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::AliasTextureNamePairList *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  result = (bool)(arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState_applyTextureAliases(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TextureUnitState_applyTextureAliases__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState_applyTextureAliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState.applyTextureAliases", 
    "    bool TextureUnitState.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool TextureUnitState.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__notifyParent(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_notifyParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","_notifyParent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  (arg1)->_notifyParent(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__getTexturePtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TexturePtr *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","_getTexturePtr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TexturePtr *) &((Ogre::TextureUnitState const *)arg1)->_getTexturePtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__getTexturePtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::TexturePtr *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","_getTexturePtr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_getTexturePtr", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::TexturePtr *) &((Ogre::TextureUnitState const *)arg1)->_getTexturePtr(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState__getTexturePtr(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TextureUnitState__getTexturePtr__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureUnitState__getTexturePtr__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TextureUnitState._getTexturePtr", 
    "    Ogre::TexturePtr const & TextureUnitState._getTexturePtr()\n"
    "    Ogre::TexturePtr const & TextureUnitState._getTexturePtr(size_t frame)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__setTexturePtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TexturePtr *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_setTexturePtr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TexturePtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TexturePtr const &","_setTexturePtr", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr const &","_setTexturePtr", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TexturePtr * >(argp2);
  (arg1)->_setTexturePtr((Ogre::TexturePtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__setTexturePtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TexturePtr *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","_setTexturePtr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TexturePtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TexturePtr const &","_setTexturePtr", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr const &","_setTexturePtr", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TexturePtr * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","_setTexturePtr", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->_setTexturePtr((Ogre::TexturePtr const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureUnitState__setTexturePtr(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_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TexturePtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TextureUnitState__setTexturePtr__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TexturePtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureUnitState__setTexturePtr__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureUnitState._setTexturePtr", 
    "    void TextureUnitState._setTexturePtr(Ogre::TexturePtr const &texptr)\n"
    "    void TextureUnitState._setTexturePtr(Ogre::TexturePtr const &texptr, size_t frame)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitState__getAnimController(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","_getAnimController", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::Controller< Ogre::Real > *)((Ogre::TextureUnitState const *)arg1)->_getAnimController();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMaterialScriptProgramDefinition;

SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_name_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  Ogre::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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(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( "", "Ogre::String const &","name", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","name", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_name_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (Ogre::String *) & ((arg1)->name);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_progType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  Ogre::GpuProgramType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","progType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","progType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  if (arg1) (arg1)->progType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_progType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramType 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","progType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (Ogre::GpuProgramType) ((arg1)->progType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_language_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  Ogre::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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","language", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(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( "", "Ogre::String const &","language", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","language", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->language = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_language_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","language", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (Ogre::String *) & ((arg1)->language);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_source_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  Ogre::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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(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( "", "Ogre::String const &","source", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","source", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->source = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_source_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (Ogre::String *) & ((arg1)->source);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_syntax_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  Ogre::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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","syntax", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(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( "", "Ogre::String const &","syntax", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","syntax", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->syntax = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_syntax_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","syntax", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (Ogre::String *) & ((arg1)->syntax);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_supportsSkeletalAnimation_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","supportsSkeletalAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","supportsSkeletalAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->supportsSkeletalAnimation = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_supportsSkeletalAnimation_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","supportsSkeletalAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (bool) ((arg1)->supportsSkeletalAnimation);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_supportsMorphAnimation_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","supportsMorphAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","supportsMorphAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->supportsMorphAnimation = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_supportsMorphAnimation_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","supportsMorphAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (bool) ((arg1)->supportsMorphAnimation);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_supportsPoseAnimation_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","supportsPoseAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","supportsPoseAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  if (arg1) (arg1)->supportsPoseAnimation = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_supportsPoseAnimation_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","supportsPoseAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (Ogre::ushort) ((arg1)->supportsPoseAnimation);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_usesVertexTextureFetch_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","usesVertexTextureFetch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","usesVertexTextureFetch", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->usesVertexTextureFetch = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_usesVertexTextureFetch_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","usesVertexTextureFetch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (bool) ((arg1)->usesVertexTextureFetch);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_customParameters_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  Ogre::vector< std::pair< Ogre::String,Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *arg2 = (Ogre::vector< std::pair< Ogre::String,Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *) 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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","customParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::vector< std::pair< Ogre::String,Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *","customParameters", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::vector< std::pair< Ogre::String,Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String,Ogre::String >,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  if (arg1) (arg1)->customParameters = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptProgramDefinition_customParameters_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptProgramDefinition *arg1 = (Ogre::MaterialScriptProgramDefinition *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::vector< std::pair< Ogre::String,Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *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_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","customParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp1);
  result = (Ogre::vector< std::pair< Ogre::String,Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *)& ((arg1)->customParameters);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MaterialScriptProgramDefinition(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MaterialScriptProgramDefinition";
  Ogre::MaterialScriptProgramDefinition *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialScriptProgramDefinition *)new Ogre::MaterialScriptProgramDefinition();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialScriptProgramDefinition(Ogre::MaterialScriptProgramDefinition *arg1) {
    delete arg1;
}

swig_class SwigClassMaterialScriptContext;

SWIGINTERN VALUE
_wrap_MaterialScriptContext_section_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::MaterialScriptSection arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","section", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::MaterialScriptSection","section", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::MaterialScriptSection >(val2);
  if (arg1) (arg1)->section = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_section_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialScriptSection 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","section", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::MaterialScriptSection) ((arg1)->section);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_groupName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","groupName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(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( "", "Ogre::String const &","groupName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","groupName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->groupName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_groupName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","groupName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::String *) & ((arg1)->groupName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_material_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::MaterialPtr *arg2 = (Ogre::MaterialPtr *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","material", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr *","material", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  if (arg1) (arg1)->material = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_material_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","material", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::MaterialPtr *)& ((arg1)->material);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_technique_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::Technique *arg2 = (Ogre::Technique *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","technique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Technique, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Technique *","technique", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Technique * >(argp2);
  if (arg1) (arg1)->technique = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_technique_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","technique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::Technique *) ((arg1)->technique);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_pass_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","pass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","pass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  if (arg1) (arg1)->pass = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_pass_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pass *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","pass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::Pass *) ((arg1)->pass);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_textureUnit_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","textureUnit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","textureUnit", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  if (arg1) (arg1)->textureUnit = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_textureUnit_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureUnitState *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","textureUnit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::TextureUnitState *) ((arg1)->textureUnit);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_program_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::GpuProgramPtr *arg2 = (Ogre::GpuProgramPtr *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","program", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramPtr *","program", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramPtr * >(argp2);
  if (arg1) (arg1)->program = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_program_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","program", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::GpuProgramPtr *)& ((arg1)->program);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isVertexProgramShadowCaster_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isVertexProgramShadowCaster", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isVertexProgramShadowCaster", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isVertexProgramShadowCaster = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isVertexProgramShadowCaster_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isVertexProgramShadowCaster", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (bool) ((arg1)->isVertexProgramShadowCaster);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isFragmentProgramShadowCaster_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isFragmentProgramShadowCaster", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isFragmentProgramShadowCaster", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isFragmentProgramShadowCaster = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isFragmentProgramShadowCaster_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isFragmentProgramShadowCaster", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (bool) ((arg1)->isFragmentProgramShadowCaster);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isVertexProgramShadowReceiver_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isVertexProgramShadowReceiver", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isVertexProgramShadowReceiver", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isVertexProgramShadowReceiver = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isVertexProgramShadowReceiver_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isVertexProgramShadowReceiver", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (bool) ((arg1)->isVertexProgramShadowReceiver);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isFragmentProgramShadowReceiver_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isFragmentProgramShadowReceiver", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isFragmentProgramShadowReceiver", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isFragmentProgramShadowReceiver = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_isFragmentProgramShadowReceiver_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","isFragmentProgramShadowReceiver", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (bool) ((arg1)->isFragmentProgramShadowReceiver);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_programParams_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::GpuProgramParametersSharedPtr *arg2 = (Ogre::GpuProgramParametersSharedPtr *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","programParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr *","programParams", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2);
  if (arg1) (arg1)->programParams = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_programParams_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramParametersSharedPtr *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","programParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::GpuProgramParametersSharedPtr *)& ((arg1)->programParams);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_numAnimationParametrics_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","numAnimationParametrics", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","numAnimationParametrics", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  if (arg1) (arg1)->numAnimationParametrics = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_numAnimationParametrics_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","numAnimationParametrics", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::ushort) ((arg1)->numAnimationParametrics);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_programDef_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::MaterialScriptProgramDefinition *arg2 = (Ogre::MaterialScriptProgramDefinition *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","programDef", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialScriptProgramDefinition, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialScriptProgramDefinition *","programDef", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialScriptProgramDefinition * >(argp2);
  if (arg1) (arg1)->programDef = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_programDef_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialScriptProgramDefinition *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","programDef", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::MaterialScriptProgramDefinition *) ((arg1)->programDef);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialScriptProgramDefinition, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_techLev_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","techLev", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","techLev", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->techLev = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_techLev_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","techLev", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (int) ((arg1)->techLev);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_passLev_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","passLev", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","passLev", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->passLev = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_passLev_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","passLev", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (int) ((arg1)->passLev);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_stateLev_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","stateLev", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","stateLev", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->stateLev = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_stateLev_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","stateLev", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (int) ((arg1)->stateLev);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_defaultParamLines_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::StringVector *arg2 = (Ogre::StringVector *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","defaultParamLines", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringVector *","defaultParamLines", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::StringVector * >(argp2);
  if (arg1) (arg1)->defaultParamLines = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_defaultParamLines_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","defaultParamLines", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::StringVector *)& ((arg1)->defaultParamLines);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_lineNo_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","lineNo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","lineNo", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  if (arg1) (arg1)->lineNo = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_lineNo_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","lineNo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result =  ((arg1)->lineNo);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_filename_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","filename", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(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( "", "Ogre::String const &","filename", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","filename", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->filename = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_filename_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","filename", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::String *) & ((arg1)->filename);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_textureAliases_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = (Ogre::AliasTextureNamePairList *) 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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","textureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,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, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList *","textureAliases", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  if (arg1) (arg1)->textureAliases = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialScriptContext_textureAliases_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialScriptContext *arg1 = (Ogre::MaterialScriptContext *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AliasTextureNamePairList *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_Ogre__MaterialScriptContext, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialScriptContext *","textureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialScriptContext * >(argp1);
  result = (Ogre::AliasTextureNamePairList *)& ((arg1)->textureAliases);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), 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, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MaterialScriptContext(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MaterialScriptContext";
  Ogre::MaterialScriptContext *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialScriptContext *)new Ogre::MaterialScriptContext();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialScriptContext(Ogre::MaterialScriptContext *arg1) {
    delete arg1;
}

swig_class SwigClassMaterialSerializer;

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

SWIGINTERN VALUE
_wrap_new_MaterialSerializer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MaterialSerializer";
  Ogre::MaterialSerializer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialSerializer *)new Ogre::MaterialSerializer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialSerializer(Ogre::MaterialSerializer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MaterialSerializer_queueForExport__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  Ogre::String *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","queueForExport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","queueForExport", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","queueForExport", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","queueForExport", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","queueForExport", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2,arg3,arg4,(Ogre::String const &)*arg5);
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_queueForExport__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","queueForExport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","queueForExport", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","queueForExport", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_queueForExport__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","queueForExport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","queueForExport", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_queueForExport__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","queueForExport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","queueForExport", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->queueForExport((Ogre::MaterialPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_queueForExport(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_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialSerializer_queueForExport__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSerializer_queueForExport__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MaterialSerializer_queueForExport__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_MaterialSerializer_queueForExport__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "MaterialSerializer.queueForExport", 
    "    void MaterialSerializer.queueForExport(Ogre::MaterialPtr const &pMat, bool clearQueued, bool exportDefaults, Ogre::String const &materialName)\n"
    "    void MaterialSerializer.queueForExport(Ogre::MaterialPtr const &pMat, bool clearQueued, bool exportDefaults)\n"
    "    void MaterialSerializer.queueForExport(Ogre::MaterialPtr const &pMat, bool clearQueued)\n"
    "    void MaterialSerializer.queueForExport(Ogre::MaterialPtr const &pMat)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportQueued__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportQueued", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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( "", "Ogre::String const &","exportQueued", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportQueued", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","exportQueued", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","exportQueued", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportQueued", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->exportQueued((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportQueued__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportQueued", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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( "", "Ogre::String const &","exportQueued", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportQueued", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","exportQueued", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->exportQueued((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportQueued__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportQueued", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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( "", "Ogre::String const &","exportQueued", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportQueued", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->exportQueued((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_exportQueued(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_Ogre__MaterialSerializer, 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_MaterialSerializer_exportQueued__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSerializer_exportQueued__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MaterialSerializer_exportQueued__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialSerializer.exportQueued", 
    "    void MaterialSerializer.exportQueued(Ogre::String const &filename, bool const includeProgDef, Ogre::String const &programFilename)\n"
    "    void MaterialSerializer.exportQueued(Ogre::String const &filename, bool const includeProgDef)\n"
    "    void MaterialSerializer.exportQueued(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportMaterial__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  Ogre::String *arg6 = 0 ;
  Ogre::String *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  {
    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 &","exportMaterial", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","exportMaterial", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","exportMaterial", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","exportMaterial", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res7 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::String const &","exportMaterial", 7, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 7, argv[5])); 
    }
    arg7 = ptr;
  }
  (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::String const &)*arg6,(Ogre::String const &)*arg7);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportMaterial__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  {
    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 &","exportMaterial", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","exportMaterial", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","exportMaterial", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","exportMaterial", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::String const &)*arg6);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportMaterial__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  {
    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 &","exportMaterial", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","exportMaterial", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","exportMaterial", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportMaterial__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  {
    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 &","exportMaterial", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","exportMaterial", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_exportMaterial__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","exportMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","exportMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  {
    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 &","exportMaterial", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMaterial", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->exportMaterial((Ogre::MaterialPtr const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_exportMaterial(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 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_MaterialSerializer_exportMaterial__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MaterialSerializer_exportMaterial__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_MaterialSerializer_exportMaterial__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_MaterialSerializer_exportMaterial__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              int res = SWIG_AsPtr_std_string(argv[5], (std::string**)(0));
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_MaterialSerializer_exportMaterial__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "MaterialSerializer.exportMaterial", 
    "    void MaterialSerializer.exportMaterial(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults, bool const includeProgDef, Ogre::String const &programFilename, Ogre::String const &materialName)\n"
    "    void MaterialSerializer.exportMaterial(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults, bool const includeProgDef, Ogre::String const &programFilename)\n"
    "    void MaterialSerializer.exportMaterial(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults, bool const includeProgDef)\n"
    "    void MaterialSerializer.exportMaterial(Ogre::MaterialPtr const &pMat, Ogre::String const &filename, bool exportDefaults)\n"
    "    void MaterialSerializer.exportMaterial(Ogre::MaterialPtr const &pMat, Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_getQueuedAsString(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer const *","getQueuedAsString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  result = (Ogre::String *) &((Ogre::MaterialSerializer const *)arg1)->getQueuedAsString();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_clearQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","clearQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  (arg1)->clearQueue();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialSerializer::Listener *arg2 = (Ogre::MaterialSerializer::Listener *) 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialSerializer__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialSerializer::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::MaterialSerializer::Listener *arg2 = (Ogre::MaterialSerializer::Listener *) 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialSerializer__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialSerializer::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_beginSection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","beginSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","beginSection", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","beginSection", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->beginSection(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_beginSection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","beginSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","beginSection", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->beginSection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_beginSection(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_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSerializer_beginSection__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSerializer_beginSection__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialSerializer.beginSection", 
    "    void MaterialSerializer.beginSection(unsigned short level, bool const useMainBuffer)\n"
    "    void MaterialSerializer.beginSection(unsigned short level)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_endSection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","endSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","endSection", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","endSection", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->endSection(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_endSection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","endSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","endSection", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->endSection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_endSection(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_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialSerializer_endSection__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSerializer_endSection__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialSerializer.endSection", 
    "    void MaterialSerializer.endSection(unsigned short level, bool const useMainBuffer)\n"
    "    void MaterialSerializer.endSection(unsigned short level)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_writeAttribute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","writeAttribute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","writeAttribute", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  {
    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 &","writeAttribute", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeAttribute", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","writeAttribute", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->writeAttribute(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_writeAttribute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","writeAttribute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","writeAttribute", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  {
    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 &","writeAttribute", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeAttribute", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->writeAttribute(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_writeAttribute(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_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _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_MaterialSerializer_writeAttribute__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MaterialSerializer_writeAttribute__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialSerializer.writeAttribute", 
    "    void MaterialSerializer.writeAttribute(unsigned short level, Ogre::String const &att, bool const useMainBuffer)\n"
    "    void MaterialSerializer.writeAttribute(unsigned short level, Ogre::String const &att)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_writeValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","writeValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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( "", "Ogre::String const &","writeValue", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeValue", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","writeValue", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->writeValue((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_writeValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","writeValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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( "", "Ogre::String const &","writeValue", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeValue", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->writeValue((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_writeValue(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_Ogre__MaterialSerializer, 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_MaterialSerializer_writeValue__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_MaterialSerializer_writeValue__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialSerializer.writeValue", 
    "    void MaterialSerializer.writeValue(Ogre::String const &val, bool const useMainBuffer)\n"
    "    void MaterialSerializer.writeValue(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_quoteWord(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","quoteWord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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( "", "Ogre::String const &","quoteWord", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","quoteWord", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->quoteWord((Ogre::String const &)*arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_writeComment__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","writeComment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","writeComment", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  {
    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 &","writeComment", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeComment", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","writeComment", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->writeComment(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialSerializer_writeComment__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialSerializer *arg1 = (Ogre::MaterialSerializer *) 0 ;
  unsigned short arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialSerializer *","writeComment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialSerializer * >(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","writeComment", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  {
    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 &","writeComment", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeComment", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->writeComment(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialSerializer_writeComment(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_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _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_MaterialSerializer_writeComment__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MaterialSerializer_writeComment__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialSerializer.writeComment", 
    "    void MaterialSerializer.writeComment(unsigned short level, Ogre::String const &comment, bool const useMainBuffer)\n"
    "    void MaterialSerializer.writeComment(unsigned short level, Ogre::String const &comment)\n");
  
  return Qnil;
}


swig_class SwigClassMaterialManager;

SWIGINTERN VALUE
_wrap_MaterialManager_DEFAULT_SCHEME_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::MaterialManager::DEFAULT_SCHEME_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_MaterialManager_DEFAULT_SCHEME_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::MaterialManager::DEFAULT_SCHEME_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::MaterialManager::DEFAULT_SCHEME_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MaterialManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MaterialManager";
  Ogre::MaterialManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialManager *)new Ogre::MaterialManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialManager(Ogre::MaterialManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MaterialManager_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_setDefaultTextureFiltering__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::TextureFilterOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","setDefaultTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureFilterOptions","setDefaultTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureFilterOptions >(val2);
  (arg1)->setDefaultTextureFiltering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_setDefaultTextureFiltering__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::FilterType arg2 ;
  Ogre::FilterOptions arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","setDefaultTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FilterType","setDefaultTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FilterType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setDefaultTextureFiltering", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FilterOptions >(val3);
  (arg1)->setDefaultTextureFiltering(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_setDefaultTextureFiltering__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::FilterOptions arg2 ;
  Ogre::FilterOptions arg3 ;
  Ogre::FilterOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","setDefaultTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setDefaultTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FilterOptions >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setDefaultTextureFiltering", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FilterOptions >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::FilterOptions","setDefaultTextureFiltering", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::FilterOptions >(val4);
  (arg1)->setDefaultTextureFiltering(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialManager_setDefaultTextureFiltering(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_Ogre__MaterialManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_MaterialManager_setDefaultTextureFiltering__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialManager, 0);
    _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_MaterialManager_setDefaultTextureFiltering__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialManager, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MaterialManager_setDefaultTextureFiltering__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MaterialManager.setDefaultTextureFiltering", 
    "    void MaterialManager.setDefaultTextureFiltering(Ogre::TextureFilterOptions fo)\n"
    "    void MaterialManager.setDefaultTextureFiltering(Ogre::FilterType ftype, Ogre::FilterOptions opts)\n"
    "    void MaterialManager.setDefaultTextureFiltering(Ogre::FilterOptions minFilter, Ogre::FilterOptions magFilter, Ogre::FilterOptions mipFilter)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_getDefaultTextureFiltering(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::FilterType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::FilterOptions 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager const *","getDefaultTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FilterType","getDefaultTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FilterType >(val2);
  result = (Ogre::FilterOptions)((Ogre::MaterialManager const *)arg1)->getDefaultTextureFiltering(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_setDefaultAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","setDefaultAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(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","setDefaultAnisotropy", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setDefaultAnisotropy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_getDefaultAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager const *","getDefaultAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  result = (unsigned int)((Ogre::MaterialManager const *)arg1)->getDefaultAnisotropy();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_getDefaultSettings(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager const *","getDefaultSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  result = ((Ogre::MaterialManager const *)arg1)->getDefaultSettings();
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager__getSchemeIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned short 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","_getSchemeIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(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( "", "Ogre::String const &","_getSchemeIndex", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getSchemeIndex", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (unsigned short)(arg1)->_getSchemeIndex((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager__getSchemeName(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String *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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","_getSchemeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(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","_getSchemeName", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::String *) &(arg1)->_getSchemeName(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager__getActiveSchemeIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager const *","_getActiveSchemeIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  result = (unsigned short)((Ogre::MaterialManager const *)arg1)->_getActiveSchemeIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_getActiveScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager const *","getActiveScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  result = (Ogre::String *) &((Ogre::MaterialManager const *)arg1)->getActiveScheme();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_setActiveScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","setActiveScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(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( "", "Ogre::String const &","setActiveScheme", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setActiveScheme", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setActiveScheme((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_addListener__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::MaterialManager::Listener *arg2 = (Ogre::MaterialManager::Listener *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialManager__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialManager::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialManager::Listener * >(argp2);
  {
    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 &","addListener", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addListener", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->addListener(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_addListener__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::MaterialManager::Listener *arg2 = (Ogre::MaterialManager::Listener *) 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialManager__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialManager::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialManager::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialManager_addListener(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_Ogre__MaterialManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialManager__Listener, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialManager_addListener__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialManager__Listener, 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_MaterialManager_addListener__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialManager.addListener", 
    "    void MaterialManager.addListener(Ogre::MaterialManager::Listener *l, Ogre::String const &schemeName)\n"
    "    void MaterialManager.addListener(Ogre::MaterialManager::Listener *l)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_removeListener__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::MaterialManager::Listener *arg2 = (Ogre::MaterialManager::Listener *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialManager__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialManager::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialManager::Listener * >(argp2);
  {
    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 &","removeListener", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeListener", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->removeListener(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_removeListener__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::MaterialManager::Listener *arg2 = (Ogre::MaterialManager::Listener *) 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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MaterialManager__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialManager::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialManager::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MaterialManager_removeListener(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_Ogre__MaterialManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialManager__Listener, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_MaterialManager_removeListener__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MaterialManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialManager__Listener, 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_MaterialManager_removeListener__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "MaterialManager.removeListener", 
    "    void MaterialManager.removeListener(Ogre::MaterialManager::Listener *l, Ogre::String const &schemeName)\n"
    "    void MaterialManager.removeListener(Ogre::MaterialManager::Listener *l)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager__arbitrateMissingTechniqueForActiveScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *arg1 = (Ogre::MaterialManager *) 0 ;
  Ogre::Material *arg2 = (Ogre::Material *) 0 ;
  unsigned short arg3 ;
  Ogre::Renderable *arg4 = (Ogre::Renderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::Technique *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_Ogre__MaterialManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialManager *","_arbitrateMissingTechniqueForActiveScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Material, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Material *","_arbitrateMissingTechniqueForActiveScheme", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Material * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","_arbitrateMissingTechniqueForActiveScheme", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Renderable const *","_arbitrateMissingTechniqueForActiveScheme", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Renderable * >(argp4);
  result = (Ogre::Technique *)(arg1)->_arbitrateMissingTechniqueForActiveScheme(arg2,arg3,(Ogre::Renderable const *)arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialManager *) &Ogre::MaterialManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialManager *)Ogre::MaterialManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassStringConverter;

SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  char arg4 ;
  std::ios::fmtflags arg5 ;
  float val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  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","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 4, argv[3] ));
  } 
  arg4 = static_cast< char >(val4);
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_std__ios__fmtflags,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "std::ios::fmtflags","Ogre::StringConverter::toString", 5, argv[4] )); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ios::fmtflags","Ogre::StringConverter::toString", 5, argv[4]));
    } else {
      arg5 = *(reinterpret_cast< std::ios::fmtflags * >(argp5));
    }
  }
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4,arg5);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  char arg4 ;
  float val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  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","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 4, argv[3] ));
  } 
  arg4 = static_cast< char >(val4);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  float val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  unsigned short arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_float(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  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","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  char arg4 ;
  std::ios::fmtflags arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Radian * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 4, argv[3] ));
  } 
  arg4 = static_cast< char >(val4);
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_std__ios__fmtflags,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "std::ios::fmtflags","Ogre::StringConverter::toString", 5, argv[4] )); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ios::fmtflags","Ogre::StringConverter::toString", 5, argv[4]));
    } else {
      arg5 = *(reinterpret_cast< std::ios::fmtflags * >(argp5));
    }
  }
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4,arg5);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  char arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Radian * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 4, argv[3] ));
  } 
  arg4 = static_cast< char >(val4);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::String 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Radian * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian arg1 ;
  unsigned short arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String 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__Radian,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Radian * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::Radian arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__Radian,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Radian * >(argp1));
    }
  }
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  char arg4 ;
  std::ios::fmtflags arg5 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Degree,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Degree * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 4, argv[3] ));
  } 
  arg4 = static_cast< char >(val4);
  {
    res5 = SWIG_ConvertPtr(argv[4], &argp5, SWIGTYPE_p_std__ios__fmtflags,  0 );
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "std::ios::fmtflags","Ogre::StringConverter::toString", 5, argv[4] )); 
    }  
    if (!argp5) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ios::fmtflags","Ogre::StringConverter::toString", 5, argv[4]));
    } else {
      arg5 = *(reinterpret_cast< std::ios::fmtflags * >(argp5));
    }
  }
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4,arg5);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  char arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  char val4 ;
  int ecode4 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  {
    res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__Degree,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Degree * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 4, argv[3] ));
  } 
  arg4 = static_cast< char >(val4);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree arg1 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::String 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(argv[0], &argp1, SWIGTYPE_p_Ogre__Degree,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Degree * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_13(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree arg1 ;
  unsigned short arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String 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__Degree,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Degree * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_14(int argc, VALUE *argv, VALUE self) {
  Ogre::Degree arg1 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__Degree,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree","Ogre::StringConverter::toString", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::Degree * >(argp1));
    }
  }
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_15(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  std::ios::fmtflags arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "int","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_std__ios__fmtflags,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3]));
    } else {
      arg4 = *(reinterpret_cast< std::ios::fmtflags * >(argp4));
    }
  }
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_16(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  Ogre::String 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","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_17(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  unsigned short arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String 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","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_18(int argc, VALUE *argv, VALUE self) {
  int arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  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( "", "int","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< int >(val1);
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_19(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  std::ios::fmtflags arg4 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_std__ios__fmtflags,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3]));
    } else {
      arg4 = *(reinterpret_cast< std::ios::fmtflags * >(argp4));
    }
  }
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_20(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_21(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  unsigned short arg2 ;
  size_t val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_22(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_23(int argc, VALUE *argv, VALUE self) {
  unsigned long arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  std::ios::fmtflags arg4 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned long >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_std__ios__fmtflags,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3]));
    } else {
      arg4 = *(reinterpret_cast< std::ios::fmtflags * >(argp4));
    }
  }
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_24(int argc, VALUE *argv, VALUE self) {
  unsigned long arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_unsigned_SS_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned long >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_25(int argc, VALUE *argv, VALUE self) {
  unsigned long arg1 ;
  unsigned short arg2 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_unsigned_SS_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned long >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_26(int argc, VALUE *argv, VALUE self) {
  unsigned long arg1 ;
  unsigned long val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned long >(val1);
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_27(int argc, VALUE *argv, VALUE self) {
  long arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  std::ios::fmtflags arg4 ;
  long val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< long >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[3], &argp4, SWIGTYPE_p_std__ios__fmtflags,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "std::ios::fmtflags","Ogre::StringConverter::toString", 4, argv[3]));
    } else {
      arg4 = *(reinterpret_cast< std::ios::fmtflags * >(argp4));
    }
  }
  result = Ogre::StringConverter::toString(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_28(int argc, VALUE *argv, VALUE self) {
  long arg1 ;
  unsigned short arg2 ;
  char arg3 ;
  long val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  char val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< long >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "char","Ogre::StringConverter::toString", 3, argv[2] ));
  } 
  arg3 = static_cast< char >(val3);
  result = Ogre::StringConverter::toString(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_29(int argc, VALUE *argv, VALUE self) {
  long arg1 ;
  unsigned short arg2 ;
  long val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< long >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_30(int argc, VALUE *argv, VALUE self) {
  long arg1 ;
  long val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< long >(val1);
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_31(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::StringConverter::toString", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = Ogre::StringConverter::toString(arg1,arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_32(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::StringConverter::toString", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = Ogre::StringConverter::toString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_33(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector2 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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 &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector2 * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::Vector2 const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_34(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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 &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector3 * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::Vector3 const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_35(int argc, VALUE *argv, VALUE self) {
  Ogre::Vector4 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__Vector4,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Vector4 * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::Vector4 const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_36(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix3 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__Matrix3,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix3 * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::Matrix3 const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_37(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__Matrix4,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::Matrix4 const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_38(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__Quaternion,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::Quaternion const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_39(int argc, VALUE *argv, VALUE self) {
  Ogre::ColourValue *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__ColourValue,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ColourValue * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::ColourValue const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_toString__SWIG_40(int argc, VALUE *argv, VALUE self) {
  Ogre::StringVector *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  Ogre::String 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__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StringVector const &","Ogre::StringConverter::toString", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StringVector const &","Ogre::StringConverter::toString", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::StringVector * >(argp1);
  result = Ogre::StringConverter::toString((Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type const &)*arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_toString(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_9(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_14(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_33(nargs, args, self);
    }
  }
  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_StringConverter_toString__SWIG_34(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_35(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_36(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_37(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_38(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_39(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_40(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_18(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_22(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_26(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_30(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_StringConverter_toString__SWIG_32(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_toString__SWIG_13(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_toString__SWIG_8(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_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_toString__SWIG_17(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_toString__SWIG_21(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_toString__SWIG_25(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_toString__SWIG_29(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_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_toString__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_bool(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_StringConverter_toString__SWIG_31(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringConverter_toString__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringConverter_toString__SWIG_12(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringConverter_toString__SWIG_16(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringConverter_toString__SWIG_20(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringConverter_toString__SWIG_24(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringConverter_toString__SWIG_28(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_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StringConverter_toString__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringConverter_toString__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringConverter_toString__SWIG_11(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__ios__fmtflags, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringConverter_toString__SWIG_15(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__ios__fmtflags, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringConverter_toString__SWIG_19(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__ios__fmtflags, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringConverter_toString__SWIG_23(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_long(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_std__ios__fmtflags, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StringConverter_toString__SWIG_27(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_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_StringConverter_toString__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__ios__fmtflags, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_StringConverter_toString__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Degree, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__ios__fmtflags, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_StringConverter_toString__SWIG_10(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_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_std__ios__fmtflags, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_StringConverter_toString__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "StringConverter.toString", 
    "    Ogre::String StringConverter.toString(Ogre::Real val, unsigned short precision, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.toString(Ogre::Real val, unsigned short precision, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.toString(Ogre::Real val, unsigned short precision, unsigned short width)\n"
    "    Ogre::String StringConverter.toString(Ogre::Real val, unsigned short precision)\n"
    "    Ogre::String StringConverter.toString(Ogre::Real val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Radian val, unsigned short precision, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.toString(Ogre::Radian val, unsigned short precision, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.toString(Ogre::Radian val, unsigned short precision, unsigned short width)\n"
    "    Ogre::String StringConverter.toString(Ogre::Radian val, unsigned short precision)\n"
    "    Ogre::String StringConverter.toString(Ogre::Radian val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Degree val, unsigned short precision, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.toString(Ogre::Degree val, unsigned short precision, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.toString(Ogre::Degree val, unsigned short precision, unsigned short width)\n"
    "    Ogre::String StringConverter.toString(Ogre::Degree val, unsigned short precision)\n"
    "    Ogre::String StringConverter.toString(Ogre::Degree val)\n"
    "    Ogre::String StringConverter.toString(int val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.toString(int val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.toString(int val, unsigned short width)\n"
    "    Ogre::String StringConverter.toString(int val)\n"
    "    Ogre::String StringConverter.toString(size_t val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.toString(size_t val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.toString(size_t val, unsigned short width)\n"
    "    Ogre::String StringConverter.toString(size_t val)\n"
    "    Ogre::String StringConverter.toString(unsigned long val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.toString(unsigned long val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.toString(unsigned long val, unsigned short width)\n"
    "    Ogre::String StringConverter.toString(unsigned long val)\n"
    "    Ogre::String StringConverter.toString(long val, unsigned short width, char fill, std::ios::fmtflags flags)\n"
    "    Ogre::String StringConverter.toString(long val, unsigned short width, char fill)\n"
    "    Ogre::String StringConverter.toString(long val, unsigned short width)\n"
    "    Ogre::String StringConverter.toString(long val)\n"
    "    Ogre::String StringConverter.toString(bool val, bool yesNo)\n"
    "    Ogre::String StringConverter.toString(bool val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Vector2 const &val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Vector3 const &val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Vector4 const &val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Matrix3 const &val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Matrix4 const &val)\n"
    "    Ogre::String StringConverter.toString(Ogre::Quaternion const &val)\n"
    "    Ogre::String StringConverter.toString(Ogre::ColourValue const &val)\n"
    "    Ogre::String StringConverter.toString(Ogre::StringVector const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseReal__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Real arg2 ;
  int res1 = SWIG_OLDOBJ ;
  float val2 ;
  int ecode2 = 0 ;
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseReal", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseReal", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::StringConverter::parseReal", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)Ogre::StringConverter::parseReal((std::string const &)*arg1,arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseReal__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Real 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( "", "Ogre::String const &","Ogre::StringConverter::parseReal", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseReal", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Real)Ogre::StringConverter::parseReal((std::string const &)*arg1);
  vresult = SWIG_From_float(static_cast< float >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseReal(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseReal__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_parseReal__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseReal", 
    "    Ogre::Real StringConverter.parseReal(Ogre::String const &val, Ogre::Real defaultValue)\n"
    "    Ogre::Real StringConverter.parseReal(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseAngle__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Radian arg2 ;
  int res1 = SWIG_OLDOBJ ;
  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;
  }
  {
    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 &","Ogre::StringConverter::parseAngle", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseAngle", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    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","Ogre::StringConverter::parseAngle", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","Ogre::StringConverter::parseAngle", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Radian * >(argp2));
    }
  }
  result = Ogre::StringConverter::parseAngle((std::string const &)*arg1,arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseAngle__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Radian 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( "", "Ogre::String const &","Ogre::StringConverter::parseAngle", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseAngle", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseAngle((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Radian(static_cast< const Ogre::Radian& >(result))), SWIGTYPE_p_Ogre__Radian, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseAngle(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseAngle__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringConverter_parseAngle__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseAngle", 
    "    Ogre::Radian StringConverter.parseAngle(Ogre::String const &val, Ogre::Radian defaultValue)\n"
    "    Ogre::Radian StringConverter.parseAngle(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseInt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  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;
  }
  {
    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 &","Ogre::StringConverter::parseInt", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseInt", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","Ogre::StringConverter::parseInt", 2, argv[1] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (int)Ogre::StringConverter::parseInt((std::string const &)*arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseInt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int 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( "", "Ogre::String const &","Ogre::StringConverter::parseInt", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseInt", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (int)Ogre::StringConverter::parseInt((std::string const &)*arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseInt(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseInt__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_parseInt__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseInt", 
    "    int StringConverter.parseInt(Ogre::String const &val, int defaultValue)\n"
    "    int StringConverter.parseInt(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseUnsignedInt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseUnsignedInt", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseUnsignedInt", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Ogre::StringConverter::parseUnsignedInt", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (unsigned int)Ogre::StringConverter::parseUnsignedInt((std::string const &)*arg1,arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseUnsignedInt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int 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( "", "Ogre::String const &","Ogre::StringConverter::parseUnsignedInt", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseUnsignedInt", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (unsigned int)Ogre::StringConverter::parseUnsignedInt((std::string const &)*arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseUnsignedInt(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseUnsignedInt__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_parseUnsignedInt__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseUnsignedInt", 
    "    unsigned int StringConverter.parseUnsignedInt(Ogre::String const &val, unsigned int defaultValue)\n"
    "    unsigned int StringConverter.parseUnsignedInt(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseLong__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  long arg2 ;
  int res1 = SWIG_OLDOBJ ;
  long val2 ;
  int ecode2 = 0 ;
  long result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseLong", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseLong", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","Ogre::StringConverter::parseLong", 2, argv[1] ));
  } 
  arg2 = static_cast< long >(val2);
  result = (long)Ogre::StringConverter::parseLong((std::string const &)*arg1,arg2);
  vresult = SWIG_From_long(static_cast< long >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseLong__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  long 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( "", "Ogre::String const &","Ogre::StringConverter::parseLong", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseLong", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (long)Ogre::StringConverter::parseLong((std::string const &)*arg1);
  vresult = SWIG_From_long(static_cast< long >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseLong(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseLong__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_parseLong__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseLong", 
    "    long StringConverter.parseLong(Ogre::String const &val, long defaultValue)\n"
    "    long StringConverter.parseLong(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseUnsignedLong__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  unsigned long arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  unsigned long result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseUnsignedLong", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseUnsignedLong", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","Ogre::StringConverter::parseUnsignedLong", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned long >(val2);
  result = (unsigned long)Ogre::StringConverter::parseUnsignedLong((std::string const &)*arg1,arg2);
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseUnsignedLong__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned long 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( "", "Ogre::String const &","Ogre::StringConverter::parseUnsignedLong", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseUnsignedLong", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (unsigned long)Ogre::StringConverter::parseUnsignedLong((std::string const &)*arg1);
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseUnsignedLong(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseUnsignedLong__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_parseUnsignedLong__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseUnsignedLong", 
    "    unsigned long StringConverter.parseUnsignedLong(Ogre::String const &val, unsigned long defaultValue)\n"
    "    unsigned long StringConverter.parseUnsignedLong(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseBool__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseBool", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseBool", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::StringConverter::parseBool", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)Ogre::StringConverter::parseBool((std::string const &)*arg1,arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseBool__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool 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( "", "Ogre::String const &","Ogre::StringConverter::parseBool", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseBool", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (bool)Ogre::StringConverter::parseBool((std::string const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseBool(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseBool__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StringConverter_parseBool__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseBool", 
    "    bool StringConverter.parseBool(Ogre::String const &val, bool defaultValue)\n"
    "    bool StringConverter.parseBool(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseVector2__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  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;
  }
  {
    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 &","Ogre::StringConverter::parseVector2", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseVector2", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  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 &","Ogre::StringConverter::parseVector2", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","Ogre::StringConverter::parseVector2", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  result = Ogre::StringConverter::parseVector2((std::string const &)*arg1,(Ogre::Vector2 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseVector2__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Vector2 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( "", "Ogre::String const &","Ogre::StringConverter::parseVector2", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseVector2", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseVector2((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Vector2(static_cast< const Ogre::Vector2& >(result))), SWIGTYPE_p_Ogre__Vector2, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseVector2(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseVector2__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringConverter_parseVector2__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseVector2", 
    "    Ogre::Vector2 StringConverter.parseVector2(Ogre::String const &val, Ogre::Vector2 const &defaultValue)\n"
    "    Ogre::Vector2 StringConverter.parseVector2(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseVector3__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  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;
  }
  {
    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 &","Ogre::StringConverter::parseVector3", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseVector3", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  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 &","Ogre::StringConverter::parseVector3", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::StringConverter::parseVector3", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = Ogre::StringConverter::parseVector3((std::string const &)*arg1,(Ogre::Vector3 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseVector3__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Vector3 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( "", "Ogre::String const &","Ogre::StringConverter::parseVector3", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseVector3", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseVector3((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Vector3(static_cast< const Ogre::Vector3& >(result))), SWIGTYPE_p_Ogre__Vector3, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseVector3(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseVector3__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_StringConverter_parseVector3__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseVector3", 
    "    Ogre::Vector3 StringConverter.parseVector3(Ogre::String const &val, Ogre::Vector3 const &defaultValue)\n"
    "    Ogre::Vector3 StringConverter.parseVector3(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseVector4__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Vector4 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseVector4", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseVector4", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","Ogre::StringConverter::parseVector4", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","Ogre::StringConverter::parseVector4", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  result = Ogre::StringConverter::parseVector4((std::string const &)*arg1,(Ogre::Vector4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseVector4__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Vector4 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( "", "Ogre::String const &","Ogre::StringConverter::parseVector4", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseVector4", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseVector4((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Vector4(static_cast< const Ogre::Vector4& >(result))), SWIGTYPE_p_Ogre__Vector4, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseVector4(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseVector4__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringConverter_parseVector4__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseVector4", 
    "    Ogre::Vector4 StringConverter.parseVector4(Ogre::String const &val, Ogre::Vector4 const &defaultValue)\n"
    "    Ogre::Vector4 StringConverter.parseVector4(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseMatrix3__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Matrix3 *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix3 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseMatrix3", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseMatrix3", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Matrix3,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const &","Ogre::StringConverter::parseMatrix3", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix3 const &","Ogre::StringConverter::parseMatrix3", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  result = Ogre::StringConverter::parseMatrix3((std::string const &)*arg1,(Ogre::Matrix3 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseMatrix3__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Matrix3 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( "", "Ogre::String const &","Ogre::StringConverter::parseMatrix3", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseMatrix3", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseMatrix3((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix3(static_cast< const Ogre::Matrix3& >(result))), SWIGTYPE_p_Ogre__Matrix3, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseMatrix3(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseMatrix3__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringConverter_parseMatrix3__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseMatrix3", 
    "    Ogre::Matrix3 StringConverter.parseMatrix3(Ogre::String const &val, Ogre::Matrix3 const &defaultValue)\n"
    "    Ogre::Matrix3 StringConverter.parseMatrix3(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseMatrix4__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Matrix4 result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseMatrix4", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseMatrix4", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","Ogre::StringConverter::parseMatrix4", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","Ogre::StringConverter::parseMatrix4", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  result = Ogre::StringConverter::parseMatrix4((std::string const &)*arg1,(Ogre::Matrix4 const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseMatrix4__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Matrix4 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( "", "Ogre::String const &","Ogre::StringConverter::parseMatrix4", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseMatrix4", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseMatrix4((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Matrix4(static_cast< const Ogre::Matrix4& >(result))), SWIGTYPE_p_Ogre__Matrix4, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseMatrix4(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseMatrix4__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringConverter_parseMatrix4__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseMatrix4", 
    "    Ogre::Matrix4 StringConverter.parseMatrix4(Ogre::String const &val, Ogre::Matrix4 const &defaultValue)\n"
    "    Ogre::Matrix4 StringConverter.parseMatrix4(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseQuaternion__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  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;
  }
  {
    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 &","Ogre::StringConverter::parseQuaternion", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseQuaternion", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::StringConverter::parseQuaternion", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::StringConverter::parseQuaternion", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  result = Ogre::StringConverter::parseQuaternion((std::string const &)*arg1,(Ogre::Quaternion const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseQuaternion__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::Quaternion 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( "", "Ogre::String const &","Ogre::StringConverter::parseQuaternion", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseQuaternion", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseQuaternion((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::Quaternion(static_cast< const Ogre::Quaternion& >(result))), SWIGTYPE_p_Ogre__Quaternion, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseQuaternion(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseQuaternion__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringConverter_parseQuaternion__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseQuaternion", 
    "    Ogre::Quaternion StringConverter.parseQuaternion(Ogre::String const &val, Ogre::Quaternion const &defaultValue)\n"
    "    Ogre::Quaternion StringConverter.parseQuaternion(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseColourValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ColourValue result;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::StringConverter::parseColourValue", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseColourValue", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","Ogre::StringConverter::parseColourValue", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","Ogre::StringConverter::parseColourValue", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  result = Ogre::StringConverter::parseColourValue((std::string const &)*arg1,(Ogre::ColourValue const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseColourValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::ColourValue 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( "", "Ogre::String const &","Ogre::StringConverter::parseColourValue", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseColourValue", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseColourValue((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::ColourValue(static_cast< const Ogre::ColourValue& >(result))), SWIGTYPE_p_Ogre__ColourValue, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_StringConverter_parseColourValue(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StringConverter_parseColourValue__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StringConverter_parseColourValue__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "StringConverter.parseColourValue", 
    "    Ogre::ColourValue StringConverter.parseColourValue(Ogre::String const &val, Ogre::ColourValue const &defaultValue)\n"
    "    Ogre::ColourValue StringConverter.parseColourValue(Ogre::String const &val)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_parseStringVector(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > 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( "", "Ogre::String const &","Ogre::StringConverter::parseStringVector", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::parseStringVector", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = Ogre::StringConverter::parseStringVector((std::string const &)*arg1);
  vresult = SWIG_NewPointerObj((new Ogre::StringVector(static_cast< const Ogre::StringVector& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StringConverter_isNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  bool 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( "", "Ogre::String const &","Ogre::StringConverter::isNumber", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StringConverter::isNumber", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (bool)Ogre::StringConverter::isNumber((std::string const &)*arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_StringConverter(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::StringConverter";
  Ogre::StringConverter *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::StringConverter *)new Ogre::StringConverter();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StringConverter(Ogre::StringConverter *arg1) {
    delete arg1;
}

swig_class SwigClassLogListener;

SWIGINTERN void
free_Ogre_LogListener(Ogre::LogListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LogListener_messageLogged(int argc, VALUE *argv, VALUE self) {
  Ogre::LogListener *arg1 = (Ogre::LogListener *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LogMessageLevel arg3 ;
  bool arg4 ;
  Ogre::String *arg5 = 0 ;
  bool *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__LogListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogListener *","messageLogged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogListener * >(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( "", "Ogre::String const &","messageLogged", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","messageLogged", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","messageLogged", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LogMessageLevel >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","messageLogged", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","messageLogged", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","messageLogged", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "bool &","messageLogged", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","messageLogged", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< bool * >(argp6);
  (arg1)->messageLogged((Ogre::String const &)*arg2,arg3,arg4,(Ogre::String const &)*arg5,*arg6);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


swig_class SwigClassLog;

SWIGINTERN VALUE
_wrap_new_Log__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  bool arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Log";
  Ogre::Log *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Log", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Log", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Log", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::Log", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::Log *)new Ogre::Log((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Log__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Log";
  Ogre::Log *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::Log", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Log", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Log", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Log *)new Ogre::Log((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Log__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Log";
  Ogre::Log *result = 0 ;
  
  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 &","Ogre::Log", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Log", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Log *)new Ogre::Log((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Log(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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Log__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Log__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_Log__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Log.new", 
    "    Log.new(Ogre::String const &name, bool debugOutput, bool suppressFileOutput)\n"
    "    Log.new(Ogre::String const &name, bool debugOutput)\n"
    "    Log.new(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Log(Ogre::Log *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Log_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  result = (Ogre::String *) &((Ogre::Log const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_isDebugOutputEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log const *","isDebugOutputEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  result = (bool)((Ogre::Log const *)arg1)->isDebugOutputEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_isFileOutputSuppressed(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log const *","isFileOutputSuppressed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  result = (bool)((Ogre::Log const *)arg1)->isFileOutputSuppressed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_isTimeStampEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log const *","isTimeStampEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  result = (bool)((Ogre::Log const *)arg1)->isTimeStampEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_logMessage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LogMessageLevel arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(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( "", "Ogre::String const &","logMessage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","logMessage", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LogMessageLevel >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","logMessage", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->logMessage((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_logMessage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LogMessageLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(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( "", "Ogre::String const &","logMessage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","logMessage", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LogMessageLevel >(val3);
  (arg1)->logMessage((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_logMessage__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(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( "", "Ogre::String const &","logMessage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->logMessage((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Log_logMessage(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_Ogre__Log, 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_Log_logMessage__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Log, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Log_logMessage__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Log, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Log_logMessage__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Log.logMessage", 
    "    void Log.logMessage(Ogre::String const &message, Ogre::LogMessageLevel lml, bool maskDebug)\n"
    "    void Log.logMessage(Ogre::String const &message, Ogre::LogMessageLevel lml)\n"
    "    void Log.logMessage(Ogre::String const &message)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_stream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::LogMessageLevel arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::Log::Stream > 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","stream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","stream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LogMessageLevel >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","stream", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->stream(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Log::Stream(static_cast< const Ogre::Log::Stream& >(result))), SWIGTYPE_p_Ogre__Log__Stream, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_stream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::LogMessageLevel arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::Log::Stream > 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","stream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","stream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LogMessageLevel >(val2);
  result = (arg1)->stream(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Log::Stream(static_cast< const Ogre::Log::Stream& >(result))), SWIGTYPE_p_Ogre__Log__Stream, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_stream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::Log::Stream > 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","stream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  result = (arg1)->stream();
  vresult = SWIG_NewPointerObj((new Ogre::Log::Stream(static_cast< const Ogre::Log::Stream& >(result))), SWIGTYPE_p_Ogre__Log__Stream, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Log_stream(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_Ogre__Log, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Log_stream__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Log, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Log_stream__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Log, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Log_stream__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Log.stream", 
    "    Ogre::Log::Stream Log.stream(Ogre::LogMessageLevel lml, bool maskDebug)\n"
    "    Ogre::Log::Stream Log.stream(Ogre::LogMessageLevel lml)\n"
    "    Ogre::Log::Stream Log.stream()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_setDebugOutputEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","setDebugOutputEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDebugOutputEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDebugOutputEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_setLogDetail(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::LoggingLevel arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","setLogDetail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LoggingLevel","setLogDetail", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LoggingLevel >(val2);
  (arg1)->setLogDetail(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_setTimeStampEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","setTimeStampEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTimeStampEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTimeStampEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_getLogDetail(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LoggingLevel 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log const *","getLogDetail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  result = (Ogre::LoggingLevel)((Ogre::Log const *)arg1)->getLogDetail();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::LogListener *arg2 = (Ogre::LogListener *) 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LogListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LogListener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LogListener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Log_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  Ogre::LogListener *arg2 = (Ogre::LogListener *) 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_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LogListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LogListener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LogListener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassLogManager;

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

SWIGINTERN VALUE
_wrap_new_LogManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::LogManager";
  Ogre::LogManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LogManager *)new Ogre::LogManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LogManager(Ogre::LogManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LogManager_createLog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::Log *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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","createLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","createLog", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createLog", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","createLog", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createLog", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createLog", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_createLog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::Log *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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","createLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","createLog", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createLog", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","createLog", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createLog", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_createLog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::Log *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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","createLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","createLog", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createLog", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","createLog", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_createLog__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Log *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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","createLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","createLog", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createLog", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Log *)(arg1)->createLog((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_LogManager_createLog(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_Ogre__LogManager, 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_LogManager_createLog__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogManager_createLog__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LogManager_createLog__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_LogManager_createLog__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "LogManager.createLog", 
    "    Ogre::Log * LogManager.createLog(Ogre::String const &name, bool defaultLog, bool debuggerOutput, bool suppressFileOutput)\n"
    "    Ogre::Log * LogManager.createLog(Ogre::String const &name, bool defaultLog, bool debuggerOutput)\n"
    "    Ogre::Log * LogManager.createLog(Ogre::String const &name, bool defaultLog)\n"
    "    Ogre::Log * LogManager.createLog(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_getLog(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Log *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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","getLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","getLog", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getLog", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Log *)(arg1)->getLog((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_getDefaultLog(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Log *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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","getDefaultLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  result = (Ogre::Log *)(arg1)->getDefaultLog();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_destroyLog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","destroyLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","destroyLog", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyLog", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyLog((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_destroyLog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::Log *arg2 = (Ogre::Log *) 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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","destroyLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Log *","destroyLog", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Log * >(argp2);
  (arg1)->destroyLog(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_LogManager_destroyLog(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_Ogre__LogManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Log, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LogManager_destroyLog__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 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_LogManager_destroyLog__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "LogManager.destroyLog", 
    "    void LogManager.destroyLog(Ogre::String const &name)\n"
    "    void LogManager.destroyLog(Ogre::Log *log)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_setDefaultLog(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::Log *arg2 = (Ogre::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::Log *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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","setDefaultLog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Log *","setDefaultLog", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Log * >(argp2);
  result = (Ogre::Log *)(arg1)->setDefaultLog(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Log, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_logMessage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LogMessageLevel arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","logMessage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","logMessage", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LogMessageLevel >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","logMessage", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->logMessage((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_logMessage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LogMessageLevel arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","logMessage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","logMessage", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::LogMessageLevel >(val3);
  (arg1)->logMessage((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_logMessage__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(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( "", "Ogre::String const &","logMessage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->logMessage((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_logMessage__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::LogMessageLevel arg2 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","logMessage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LogMessageLevel >(val2);
  {
    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 &","logMessage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","logMessage", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->logMessage(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_logMessage__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::LogMessageLevel arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","logMessage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","logMessage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LogMessageLevel >(val2);
  {
    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 &","logMessage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","logMessage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->logMessage(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_LogManager_logMessage(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_Ogre__LogManager, 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_LogManager_logMessage__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _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_LogManager_logMessage__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogManager_logMessage__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LogManager_logMessage__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_LogManager_logMessage__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "LogManager.logMessage", 
    "    void LogManager.logMessage(Ogre::String const &message, Ogre::LogMessageLevel lml, bool maskDebug)\n"
    "    void LogManager.logMessage(Ogre::String const &message, Ogre::LogMessageLevel lml)\n"
    "    void LogManager.logMessage(Ogre::String const &message)\n"
    "    void LogManager.logMessage(Ogre::LogMessageLevel lml, Ogre::String const &message, bool maskDebug)\n"
    "    void LogManager.logMessage(Ogre::LogMessageLevel lml, Ogre::String const &message)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_stream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::LogMessageLevel arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::Log::Stream > 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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","stream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","stream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LogMessageLevel >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","stream", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->stream(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::Log::Stream(static_cast< const Ogre::Log::Stream& >(result))), SWIGTYPE_p_Ogre__Log__Stream, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_stream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::LogMessageLevel arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::Log::Stream > 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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","stream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LogMessageLevel","stream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LogMessageLevel >(val2);
  result = (arg1)->stream(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Log::Stream(static_cast< const Ogre::Log::Stream& >(result))), SWIGTYPE_p_Ogre__Log__Stream, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_stream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::Log::Stream > 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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","stream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  result = (arg1)->stream();
  vresult = SWIG_NewPointerObj((new Ogre::Log::Stream(static_cast< const Ogre::Log::Stream& >(result))), SWIGTYPE_p_Ogre__Log__Stream, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_LogManager_stream(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_Ogre__LogManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_LogManager_stream__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_LogManager_stream__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LogManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_LogManager_stream__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "LogManager.stream", 
    "    Ogre::Log::Stream LogManager.stream(Ogre::LogMessageLevel lml, bool maskDebug)\n"
    "    Ogre::Log::Stream LogManager.stream(Ogre::LogMessageLevel lml)\n"
    "    Ogre::Log::Stream LogManager.stream()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_setLogDetail(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *arg1 = (Ogre::LogManager *) 0 ;
  Ogre::LoggingLevel arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__LogManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LogManager *","setLogDetail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LogManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::LoggingLevel","setLogDetail", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::LoggingLevel >(val2);
  (arg1)->setLogDetail(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LogManager *) &Ogre::LogManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LogManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LogManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::LogManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LogManager *)Ogre::LogManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LogManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDriverVersion;

SWIGINTERN VALUE
_wrap_DriverVersion_major_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","major", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","major", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->major = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_major_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","major", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  result = (int) ((arg1)->major);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_minor_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","minor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","minor", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->minor = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_minor_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","minor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  result = (int) ((arg1)->minor);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_release_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","release", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","release", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->release = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_release_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","release", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  result = (int) ((arg1)->release);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_build_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","build", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->build = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_build_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  result = (int) ((arg1)->build);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_DriverVersion(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DriverVersion";
  Ogre::DriverVersion *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DriverVersion *)new Ogre::DriverVersion();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_toString(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion const *","toString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(argp1);
  result = ((Ogre::DriverVersion const *)arg1)->toString();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DriverVersion_fromString(int argc, VALUE *argv, VALUE self) {
  Ogre::DriverVersion *arg1 = (Ogre::DriverVersion *) 0 ;
  Ogre::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_Ogre__DriverVersion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DriverVersion *","fromString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DriverVersion * >(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( "", "Ogre::String const &","fromString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","fromString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->fromString((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_DriverVersion(Ogre::DriverVersion *arg1) {
    delete arg1;
}

swig_class SwigClassRenderSystemCapabilities;

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

SWIGINTERN VALUE
_wrap_new_RenderSystemCapabilities(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderSystemCapabilities";
  Ogre::RenderSystemCapabilities *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderSystemCapabilities *)new Ogre::RenderSystemCapabilities();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderSystemCapabilities(Ogre::RenderSystemCapabilities *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_calculateSize(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","calculateSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = ((Ogre::RenderSystemCapabilities const *)arg1)->calculateSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setDriverVersion(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::DriverVersion *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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setDriverVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__DriverVersion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DriverVersion const &","setDriverVersion", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DriverVersion const &","setDriverVersion", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DriverVersion * >(argp2);
  (arg1)->setDriverVersion((Ogre::DriverVersion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_parseDriverVersionFromString(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","parseDriverVersionFromString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(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( "", "Ogre::String const &","parseDriverVersionFromString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseDriverVersionFromString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->parseDriverVersionFromString((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getDriverVersion(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::DriverVersion 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getDriverVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = ((Ogre::RenderSystemCapabilities const *)arg1)->getDriverVersion();
  vresult = SWIG_NewPointerObj((new Ogre::DriverVersion(static_cast< const Ogre::DriverVersion& >(result))), SWIGTYPE_p_Ogre__DriverVersion, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getVendor(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GPUVendor 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getVendor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::GPUVendor)((Ogre::RenderSystemCapabilities const *)arg1)->getVendor();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setVendor(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::GPUVendor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setVendor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GPUVendor","setVendor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GPUVendor >(val2);
  (arg1)->setVendor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_parseVendorFromString(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","parseVendorFromString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(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( "", "Ogre::String const &","parseVendorFromString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseVendorFromString", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->parseVendorFromString((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_vendorFromString(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::GPUVendor 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( "", "Ogre::String const &","Ogre::RenderSystemCapabilities::vendorFromString", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RenderSystemCapabilities::vendorFromString", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::GPUVendor)Ogre::RenderSystemCapabilities::vendorFromString((std::string const &)*arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_vendorToString(int argc, VALUE *argv, VALUE self) {
  Ogre::GPUVendor arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::GPUVendor","Ogre::RenderSystemCapabilities::vendorToString", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::GPUVendor >(val1);
  result = Ogre::RenderSystemCapabilities::vendorToString(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_isDriverOlderThanVersion(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::DriverVersion arg2 ;
  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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","isDriverOlderThanVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__DriverVersion,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DriverVersion","isDriverOlderThanVersion", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DriverVersion","isDriverOlderThanVersion", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::DriverVersion * >(argp2));
    }
  }
  result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->isDriverOlderThanVersion(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setNumWorldMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setNumWorldMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setNumWorldMatrices", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setNumWorldMatrices(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setNumTextureUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setNumTextureUnits", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setNumTextureUnits", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setNumTextureUnits(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setStencilBufferBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setStencilBufferBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setStencilBufferBitDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setStencilBufferBitDepth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setNumVertexBlendMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setNumVertexBlendMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setNumVertexBlendMatrices", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setNumVertexBlendMatrices(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setNumMultiRenderTargets(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setNumMultiRenderTargets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setNumMultiRenderTargets", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setNumMultiRenderTargets(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getNumWorldMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getNumWorldMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumWorldMatrices();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getNumTextureUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getNumTextureUnits", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumTextureUnits();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getStencilBufferBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getStencilBufferBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getStencilBufferBitDepth();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getNumVertexBlendMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getNumVertexBlendMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumVertexBlendMatrices();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getNumMultiRenderTargets(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getNumMultiRenderTargets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumMultiRenderTargets();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_isCapabilityRenderSystemSpecific(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::Capabilities arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","isCapabilityRenderSystemSpecific", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Capabilities","isCapabilityRenderSystemSpecific", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Capabilities >(val2);
  result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->isCapabilityRenderSystemSpecific(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setCapability(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::Capabilities arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setCapability", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Capabilities","setCapability", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Capabilities >(val2);
  (arg1)->setCapability(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_unsetCapability(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::Capabilities arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","unsetCapability", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Capabilities","unsetCapability", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Capabilities >(val2);
  (arg1)->unsetCapability(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_hasCapability(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::Capabilities arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","hasCapability", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Capabilities","hasCapability", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Capabilities >(val2);
  result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->hasCapability(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_addShaderProfile(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","addShaderProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(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( "", "Ogre::String const &","addShaderProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addShaderProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addShaderProfile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_removeShaderProfile(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","removeShaderProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(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( "", "Ogre::String const &","removeShaderProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeShaderProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeShaderProfile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_isShaderProfileSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","isShaderProfileSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(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( "", "Ogre::String const &","isShaderProfileSupported", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isShaderProfileSupported", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->isShaderProfileSupported((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getSupportedShaderProfiles(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystemCapabilities::ShaderProfiles *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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getSupportedShaderProfiles", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::RenderSystemCapabilities::ShaderProfiles *) &((Ogre::RenderSystemCapabilities const *)arg1)->getSupportedShaderProfiles();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getVertexProgramConstantFloatCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getVertexProgramConstantFloatCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexProgramConstantFloatCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getVertexProgramConstantIntCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getVertexProgramConstantIntCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexProgramConstantIntCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getVertexProgramConstantBoolCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getVertexProgramConstantBoolCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexProgramConstantBoolCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getGeometryProgramConstantFloatCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getGeometryProgramConstantFloatCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramConstantFloatCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getGeometryProgramConstantIntCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getGeometryProgramConstantIntCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramConstantIntCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getGeometryProgramConstantBoolCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getGeometryProgramConstantBoolCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramConstantBoolCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getFragmentProgramConstantFloatCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getFragmentProgramConstantFloatCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getFragmentProgramConstantFloatCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getFragmentProgramConstantIntCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getFragmentProgramConstantIntCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getFragmentProgramConstantIntCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getFragmentProgramConstantBoolCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getFragmentProgramConstantBoolCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getFragmentProgramConstantBoolCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setDeviceName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setDeviceName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(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( "", "Ogre::String const &","setDeviceName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setDeviceName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setDeviceName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getDeviceName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getDeviceName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = ((Ogre::RenderSystemCapabilities const *)arg1)->getDeviceName();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setVertexProgramConstantFloatCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setVertexProgramConstantFloatCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setVertexProgramConstantFloatCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setVertexProgramConstantFloatCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setVertexProgramConstantIntCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setVertexProgramConstantIntCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setVertexProgramConstantIntCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setVertexProgramConstantIntCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setVertexProgramConstantBoolCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setVertexProgramConstantBoolCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setVertexProgramConstantBoolCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setVertexProgramConstantBoolCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setGeometryProgramConstantFloatCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setGeometryProgramConstantFloatCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setGeometryProgramConstantFloatCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setGeometryProgramConstantFloatCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setGeometryProgramConstantIntCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setGeometryProgramConstantIntCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setGeometryProgramConstantIntCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setGeometryProgramConstantIntCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setGeometryProgramConstantBoolCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setGeometryProgramConstantBoolCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setGeometryProgramConstantBoolCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setGeometryProgramConstantBoolCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setFragmentProgramConstantFloatCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setFragmentProgramConstantFloatCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setFragmentProgramConstantFloatCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setFragmentProgramConstantFloatCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setFragmentProgramConstantIntCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setFragmentProgramConstantIntCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setFragmentProgramConstantIntCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setFragmentProgramConstantIntCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setFragmentProgramConstantBoolCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setFragmentProgramConstantBoolCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setFragmentProgramConstantBoolCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setFragmentProgramConstantBoolCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setMaxPointSize(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setMaxPointSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaxPointSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaxPointSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getMaxPointSize(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getMaxPointSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::Real)((Ogre::RenderSystemCapabilities const *)arg1)->getMaxPointSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setNonPOW2TexturesLimited(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setNonPOW2TexturesLimited", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setNonPOW2TexturesLimited", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setNonPOW2TexturesLimited(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getNonPOW2TexturesLimited(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getNonPOW2TexturesLimited", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->getNonPOW2TexturesLimited();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setNumVertexTextureUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setNumVertexTextureUnits", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setNumVertexTextureUnits", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setNumVertexTextureUnits(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getNumVertexTextureUnits(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getNumVertexTextureUnits", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (Ogre::ushort)((Ogre::RenderSystemCapabilities const *)arg1)->getNumVertexTextureUnits();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setVertexTextureUnitsShared(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setVertexTextureUnitsShared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVertexTextureUnitsShared", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVertexTextureUnitsShared(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getVertexTextureUnitsShared(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getVertexTextureUnitsShared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (bool)((Ogre::RenderSystemCapabilities const *)arg1)->getVertexTextureUnitsShared();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setGeometryProgramNumOutputVertices(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setGeometryProgramNumOutputVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setGeometryProgramNumOutputVertices", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setGeometryProgramNumOutputVertices(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getGeometryProgramNumOutputVertices(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getGeometryProgramNumOutputVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = (int)((Ogre::RenderSystemCapabilities const *)arg1)->getGeometryProgramNumOutputVertices();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_getRenderSystemName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","getRenderSystemName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  result = ((Ogre::RenderSystemCapabilities const *)arg1)->getRenderSystemName();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setRenderSystemName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setRenderSystemName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(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( "", "Ogre::String const &","setRenderSystemName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setRenderSystemName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setRenderSystemName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_setCategoryRelevant(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::CapabilitiesCategory arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","setCategoryRelevant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CapabilitiesCategory","setCategoryRelevant", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CapabilitiesCategory >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setCategoryRelevant", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setCategoryRelevant(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_isCategoryRelevant(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::CapabilitiesCategory arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","isCategoryRelevant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CapabilitiesCategory","isCategoryRelevant", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CapabilitiesCategory >(val2);
  result = (bool)(arg1)->isCategoryRelevant(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilities_log(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilities *arg1 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::Log *arg2 = (Ogre::Log *) 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_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","log", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Log *","log", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Log * >(argp2);
  (arg1)->log(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassTextureManager;

SWIGINTERN void
free_Ogre_TextureManager(Ogre::TextureManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TextureManager_createOrRetrieve__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::TextureType arg7 ;
  int arg8 ;
  Ogre::Real arg9 ;
  bool arg10 ;
  Ogre::PixelFormat arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::TextureType","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::TextureType >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_float(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::Real","createOrRetrieve", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::Real >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createOrRetrieve", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::PixelFormat >(val11);
  ecode12 = SWIG_AsVal_bool(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 12, argv[10] ));
  } 
  arg12 = static_cast< bool >(val12);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::TextureType arg7 ;
  int arg8 ;
  Ogre::Real arg9 ;
  bool arg10 ;
  Ogre::PixelFormat arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::TextureType","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::TextureType >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_float(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::Real","createOrRetrieve", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::Real >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createOrRetrieve", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::PixelFormat >(val11);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10,arg11);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::TextureType arg7 ;
  int arg8 ;
  Ogre::Real arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::TextureType","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::TextureType >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_float(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::Real","createOrRetrieve", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::Real >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::TextureType arg7 ;
  int arg8 ;
  Ogre::Real arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  float val9 ;
  int ecode9 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::TextureType","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::TextureType >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_float(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::Real","createOrRetrieve", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::Real >(val9);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::TextureType arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::TextureType","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::TextureType >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::TextureType arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::TextureType","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::TextureType >(val7);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_TextureManager_createOrRetrieve(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[13];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 13) 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_Ogre__TextureManager, 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_TextureManager_createOrRetrieve__SWIG_9(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureManager_createOrRetrieve__SWIG_8(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TextureManager_createOrRetrieve__SWIG_7(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_TextureManager_createOrRetrieve__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureManager_createOrRetrieve__SWIG_5(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TextureManager_createOrRetrieve__SWIG_4(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TextureManager_createOrRetrieve__SWIG_3(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_TextureManager_createOrRetrieve__SWIG_2(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_TextureManager_createOrRetrieve__SWIG_1(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_float(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_TextureManager_createOrRetrieve__SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "TextureManager.createOrRetrieve", 
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat, bool hwGammaCorrection)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams, Ogre::TextureType texType, int numMipmaps)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams, Ogre::TextureType texType)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *createParams)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult TextureManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::PixelFormat arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","prepare", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","prepare", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","prepare", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","prepare", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::PixelFormat arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","prepare", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","prepare", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","prepare", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_prepare__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","prepare", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","prepare", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_prepare__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","prepare", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_prepare__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::TexturePtr result;
  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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_prepare__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::TexturePtr 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_prepare__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::TexturePtr 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_prepare(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[10];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 10) 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_Ogre__TextureManager, 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_TextureManager_prepare__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureManager_prepare__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_TextureManager_prepare__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TextureManager_prepare__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureManager_prepare__SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TextureManager_prepare__SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TextureManager_prepare__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "TextureManager.prepare", 
    "    Ogre::TexturePtr TextureManager.prepare(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat, bool hwGammaCorrection)\n"
    "    Ogre::TexturePtr TextureManager.prepare(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat)\n"
    "    Ogre::TexturePtr TextureManager.prepare(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha)\n"
    "    Ogre::TexturePtr TextureManager.prepare(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma)\n"
    "    Ogre::TexturePtr TextureManager.prepare(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps)\n"
    "    Ogre::TexturePtr TextureManager.prepare(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType)\n"
    "    Ogre::TexturePtr TextureManager.prepare(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::PixelFormat arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","load", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","load", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","load", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","load", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","load", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::PixelFormat arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","load", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","load", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","load", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","load", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","load", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","load", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","load", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_load__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","load", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","load", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_load__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  int arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::TexturePtr result;
  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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","load", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_load__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::TexturePtr 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_load__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::TexturePtr 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_load(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[10];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 10) 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_Ogre__TextureManager, 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_TextureManager_load__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureManager_load__SWIG_5(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_TextureManager_load__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TextureManager_load__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureManager_load__SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TextureManager_load__SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            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_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TextureManager_load__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "TextureManager.load", 
    "    Ogre::TexturePtr TextureManager.load(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat, bool hwGammaCorrection)\n"
    "    Ogre::TexturePtr TextureManager.load(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat)\n"
    "    Ogre::TexturePtr TextureManager.load(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma, bool isAlpha)\n"
    "    Ogre::TexturePtr TextureManager.load(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps, Ogre::Real gamma)\n"
    "    Ogre::TexturePtr TextureManager.load(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, int numMipmaps)\n"
    "    Ogre::TexturePtr TextureManager.load(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType)\n"
    "    Ogre::TexturePtr TextureManager.load(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_loadImage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Image *arg4 = 0 ;
  Ogre::TextureType arg5 ;
  int arg6 ;
  Ogre::Real arg7 ;
  bool arg8 ;
  Ogre::PixelFormat arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::TextureType","loadImage", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::TextureType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","loadImage", 6, argv[4] ));
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","loadImage", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","loadImage", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadImage", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","loadImage", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadImage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Image *arg4 = 0 ;
  Ogre::TextureType arg5 ;
  int arg6 ;
  Ogre::Real arg7 ;
  bool arg8 ;
  Ogre::PixelFormat arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::TextureType","loadImage", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::TextureType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","loadImage", 6, argv[4] ));
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","loadImage", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","loadImage", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadImage", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadImage__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Image *arg4 = 0 ;
  Ogre::TextureType arg5 ;
  int arg6 ;
  Ogre::Real arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::TextureType","loadImage", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::TextureType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","loadImage", 6, argv[4] ));
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","loadImage", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","loadImage", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadImage__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Image *arg4 = 0 ;
  Ogre::TextureType arg5 ;
  int arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::TextureType","loadImage", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::TextureType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","loadImage", 6, argv[4] ));
  } 
  arg6 = static_cast< int >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","loadImage", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadImage__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Image *arg4 = 0 ;
  Ogre::TextureType arg5 ;
  int arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::TextureType","loadImage", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::TextureType >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "int","loadImage", 6, argv[4] ));
  } 
  arg6 = static_cast< int >(val6);
  result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadImage__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Image *arg4 = 0 ;
  Ogre::TextureType arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::TexturePtr result;
  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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::TextureType","loadImage", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::TextureType >(val5);
  result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadImage__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Image *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::TexturePtr 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  result = (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Image const &)*arg4);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadImage(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[11];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 11) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TextureManager_loadImage__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_TextureManager_loadImage__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _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_TextureManager_loadImage__SWIG_4(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _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) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureManager_loadImage__SWIG_3(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _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) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TextureManager_loadImage__SWIG_2(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _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) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TextureManager_loadImage__SWIG_1(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _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) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_TextureManager_loadImage__SWIG_0(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "TextureManager.loadImage", 
    "    Ogre::TexturePtr TextureManager.loadImage(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType, int iNumMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat, bool hwGammaCorrection)\n"
    "    Ogre::TexturePtr TextureManager.loadImage(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType, int iNumMipmaps, Ogre::Real gamma, bool isAlpha, Ogre::PixelFormat desiredFormat)\n"
    "    Ogre::TexturePtr TextureManager.loadImage(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType, int iNumMipmaps, Ogre::Real gamma, bool isAlpha)\n"
    "    Ogre::TexturePtr TextureManager.loadImage(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType, int iNumMipmaps, Ogre::Real gamma)\n"
    "    Ogre::TexturePtr TextureManager.loadImage(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType, int iNumMipmaps)\n"
    "    Ogre::TexturePtr TextureManager.loadImage(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img, Ogre::TextureType texType)\n"
    "    Ogre::TexturePtr TextureManager.loadImage(Ogre::String const &name, Ogre::String const &group, Ogre::Image const &img)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_loadRawData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::DataStreamPtr *arg4 = 0 ;
  Ogre::ushort arg5 ;
  Ogre::ushort arg6 ;
  Ogre::PixelFormat arg7 ;
  Ogre::TextureType arg8 ;
  int arg9 ;
  Ogre::Real arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  float val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadRawData", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 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 &","loadRawData", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::DataStreamPtr * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::ushort >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::ushort >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::PixelFormat >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::TextureType","loadRawData", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::TextureType >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","loadRawData", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_float(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::Real","loadRawData", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::Real >(val10);
  ecode11 = SWIG_AsVal_bool(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "bool","loadRawData", 11, argv[9] ));
  } 
  arg11 = static_cast< bool >(val11);
  result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadRawData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::DataStreamPtr *arg4 = 0 ;
  Ogre::ushort arg5 ;
  Ogre::ushort arg6 ;
  Ogre::PixelFormat arg7 ;
  Ogre::TextureType arg8 ;
  int arg9 ;
  Ogre::Real arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  float val10 ;
  int ecode10 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadRawData", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 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 &","loadRawData", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::DataStreamPtr * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::ushort >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::ushort >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::PixelFormat >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::TextureType","loadRawData", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::TextureType >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","loadRawData", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_float(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::Real","loadRawData", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::Real >(val10);
  result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadRawData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::DataStreamPtr *arg4 = 0 ;
  Ogre::ushort arg5 ;
  Ogre::ushort arg6 ;
  Ogre::PixelFormat arg7 ;
  Ogre::TextureType arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadRawData", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 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 &","loadRawData", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::DataStreamPtr * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::ushort >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::ushort >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::PixelFormat >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::TextureType","loadRawData", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::TextureType >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","loadRawData", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadRawData__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::DataStreamPtr *arg4 = 0 ;
  Ogre::ushort arg5 ;
  Ogre::ushort arg6 ;
  Ogre::PixelFormat arg7 ;
  Ogre::TextureType arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadRawData", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 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 &","loadRawData", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::DataStreamPtr * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::ushort >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::ushort >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::PixelFormat >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::TextureType","loadRawData", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::TextureType >(val8);
  result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadRawData__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::DataStreamPtr *arg4 = 0 ;
  Ogre::ushort arg5 ;
  Ogre::ushort arg6 ;
  Ogre::PixelFormat arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","loadRawData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","loadRawData", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 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 &","loadRawData", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadRawData", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadRawData", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::DataStreamPtr * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::ushort >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::ushort","loadRawData", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::ushort >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::PixelFormat","loadRawData", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::PixelFormat >(val7);
  result = (arg1)->loadRawData((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,*arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_loadRawData(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[12];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 12) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TextureManager_loadRawData__SWIG_4(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TextureManager_loadRawData__SWIG_3(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TextureManager_loadRawData__SWIG_2(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_float(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_TextureManager_loadRawData__SWIG_1(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_float(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_TextureManager_loadRawData__SWIG_0(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 12, "TextureManager.loadRawData", 
    "    Ogre::TexturePtr TextureManager.loadRawData(Ogre::String const &name, Ogre::String const &group, Ogre::DataStreamPtr &stream, Ogre::ushort uWidth, Ogre::ushort uHeight, Ogre::PixelFormat format, Ogre::TextureType texType, int iNumMipmaps, Ogre::Real gamma, bool hwGammaCorrection)\n"
    "    Ogre::TexturePtr TextureManager.loadRawData(Ogre::String const &name, Ogre::String const &group, Ogre::DataStreamPtr &stream, Ogre::ushort uWidth, Ogre::ushort uHeight, Ogre::PixelFormat format, Ogre::TextureType texType, int iNumMipmaps, Ogre::Real gamma)\n"
    "    Ogre::TexturePtr TextureManager.loadRawData(Ogre::String const &name, Ogre::String const &group, Ogre::DataStreamPtr &stream, Ogre::ushort uWidth, Ogre::ushort uHeight, Ogre::PixelFormat format, Ogre::TextureType texType, int iNumMipmaps)\n"
    "    Ogre::TexturePtr TextureManager.loadRawData(Ogre::String const &name, Ogre::String const &group, Ogre::DataStreamPtr &stream, Ogre::ushort uWidth, Ogre::ushort uHeight, Ogre::PixelFormat format, Ogre::TextureType texType)\n"
    "    Ogre::TexturePtr TextureManager.loadRawData(Ogre::String const &name, Ogre::String const &group, Ogre::DataStreamPtr &stream, Ogre::ushort uWidth, Ogre::ushort uHeight, Ogre::PixelFormat format)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_createManual__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  Ogre::uint arg7 ;
  int arg8 ;
  Ogre::PixelFormat arg9 ;
  int arg10 ;
  Ogre::ManualResourceLoader *arg11 = (Ogre::ManualResourceLoader *) 0 ;
  bool arg12 ;
  Ogre::uint arg13 ;
  Ogre::String *arg14 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  unsigned int val13 ;
  int ecode13 = 0 ;
  int res14 = SWIG_OLDOBJ ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 13) || (argc > 13)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 13)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","createManual", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  res11 = SWIG_ConvertPtr(argv[9], &argp11,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 11, argv[9] )); 
  }
  arg11 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp11);
  ecode12 = SWIG_AsVal_bool(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "bool","createManual", 12, argv[10] ));
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_unsigned_SS_int(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::uint >(val13);
  {
    std::string *ptr = (std::string *)0;
    res14 = SWIG_AsPtr_std_string(argv[12], &ptr);
    if (!SWIG_IsOK(res14)) {
      SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::String const &","createManual", 14, argv[12] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 14, argv[12])); 
    }
    arg14 = ptr;
  }
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::String const &)*arg14);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res14)) delete arg14;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res14)) delete arg14;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_createManual__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  Ogre::uint arg7 ;
  int arg8 ;
  Ogre::PixelFormat arg9 ;
  int arg10 ;
  Ogre::ManualResourceLoader *arg11 = (Ogre::ManualResourceLoader *) 0 ;
  bool arg12 ;
  Ogre::uint arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  unsigned int val13 ;
  int ecode13 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 12) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","createManual", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  res11 = SWIG_ConvertPtr(argv[9], &argp11,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 11, argv[9] )); 
  }
  arg11 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp11);
  ecode12 = SWIG_AsVal_bool(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "bool","createManual", 12, argv[10] ));
  } 
  arg12 = static_cast< bool >(val12);
  ecode13 = SWIG_AsVal_unsigned_SS_int(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::uint >(val13);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  Ogre::uint arg7 ;
  int arg8 ;
  Ogre::PixelFormat arg9 ;
  int arg10 ;
  Ogre::ManualResourceLoader *arg11 = (Ogre::ManualResourceLoader *) 0 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","createManual", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  res11 = SWIG_ConvertPtr(argv[9], &argp11,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 11, argv[9] )); 
  }
  arg11 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp11);
  ecode12 = SWIG_AsVal_bool(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "bool","createManual", 12, argv[10] ));
  } 
  arg12 = static_cast< bool >(val12);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  Ogre::uint arg7 ;
  int arg8 ;
  Ogre::PixelFormat arg9 ;
  int arg10 ;
  Ogre::ManualResourceLoader *arg11 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","createManual", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  res11 = SWIG_ConvertPtr(argv[9], &argp11,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 11, argv[9] )); 
  }
  arg11 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp11);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  Ogre::uint arg7 ;
  int arg8 ;
  Ogre::PixelFormat arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","createManual", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  Ogre::uint arg7 ;
  int arg8 ;
  Ogre::PixelFormat arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PixelFormat >(val9);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  int arg7 ;
  Ogre::PixelFormat arg8 ;
  int arg9 ;
  Ogre::ManualResourceLoader *arg10 = (Ogre::ManualResourceLoader *) 0 ;
  bool arg11 ;
  Ogre::uint arg12 ;
  Ogre::String *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  int res13 = SWIG_OLDOBJ ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 12) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  res10 = SWIG_ConvertPtr(argv[8], &argp10,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 10, argv[8] )); 
  }
  arg10 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp10);
  ecode11 = SWIG_AsVal_bool(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "bool","createManual", 11, argv[9] ));
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::uint >(val12);
  {
    std::string *ptr = (std::string *)0;
    res13 = SWIG_AsPtr_std_string(argv[11], &ptr);
    if (!SWIG_IsOK(res13)) {
      SWIG_exception_fail(SWIG_ArgError(res13), Ruby_Format_TypeError( "", "Ogre::String const &","createManual", 13, argv[11] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 13, argv[11])); 
    }
    arg13 = ptr;
  }
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(Ogre::String const &)*arg13);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res13)) delete arg13;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res13)) delete arg13;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_createManual__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  int arg7 ;
  Ogre::PixelFormat arg8 ;
  int arg9 ;
  Ogre::ManualResourceLoader *arg10 = (Ogre::ManualResourceLoader *) 0 ;
  bool arg11 ;
  Ogre::uint arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  unsigned int val12 ;
  int ecode12 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  res10 = SWIG_ConvertPtr(argv[8], &argp10,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 10, argv[8] )); 
  }
  arg10 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp10);
  ecode11 = SWIG_AsVal_bool(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "bool","createManual", 11, argv[9] ));
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_unsigned_SS_int(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::uint >(val12);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  int arg7 ;
  Ogre::PixelFormat arg8 ;
  int arg9 ;
  Ogre::ManualResourceLoader *arg10 = (Ogre::ManualResourceLoader *) 0 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  res10 = SWIG_ConvertPtr(argv[8], &argp10,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 10, argv[8] )); 
  }
  arg10 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp10);
  ecode11 = SWIG_AsVal_bool(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "bool","createManual", 11, argv[9] ));
  } 
  arg11 = static_cast< bool >(val11);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  int arg7 ;
  Ogre::PixelFormat arg8 ;
  int arg9 ;
  Ogre::ManualResourceLoader *arg10 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  res10 = SWIG_ConvertPtr(argv[8], &argp10,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 10, argv[8] )); 
  }
  arg10 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp10);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  int arg7 ;
  Ogre::PixelFormat arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createManual", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::TextureType arg4 ;
  Ogre::uint arg5 ;
  Ogre::uint arg6 ;
  int arg7 ;
  Ogre::PixelFormat arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  unsigned int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::TextureType","createManual", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::TextureType >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint","createManual", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createManual", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PixelFormat","createManual", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PixelFormat >(val8);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, 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_TextureManager_createManual(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[15];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 15) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TextureManager_createManual__SWIG_11(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TextureManager_createManual__SWIG_5(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TextureManager_createManual__SWIG_10(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_TextureManager_createManual__SWIG_4(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_TextureManager_createManual__SWIG_9(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_TextureManager_createManual__SWIG_3(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_TextureManager_createManual__SWIG_8(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_TextureManager_createManual__SWIG_2(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_TextureManager_createManual__SWIG_7(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_unsigned_SS_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_TextureManager_createManual__SWIG_1(nargs, args, self);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_unsigned_SS_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            int res = SWIG_AsPtr_std_string(argv[12], (std::string**)(0));
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_TextureManager_createManual__SWIG_6(nargs, args, self);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 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) {
          {
            int res = SWIG_AsVal_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) {
              {
                int res = SWIG_AsVal_unsigned_SS_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        void *vptr = 0;
                        int res = SWIG_ConvertPtr(argv[10], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_unsigned_SS_int(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              int res = SWIG_AsPtr_std_string(argv[13], (std::string**)(0));
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_TextureManager_createManual__SWIG_0(nargs, args, self);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 15, "TextureManager.createManual", 
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, Ogre::uint depth, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader, bool hwGammaCorrection, Ogre::uint fsaa, Ogre::String const &fsaaHint)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, Ogre::uint depth, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader, bool hwGammaCorrection, Ogre::uint fsaa)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, Ogre::uint depth, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader, bool hwGammaCorrection)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, Ogre::uint depth, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, Ogre::uint depth, int num_mips, Ogre::PixelFormat format, int usage)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, Ogre::uint depth, int num_mips, Ogre::PixelFormat format)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader, bool hwGammaCorrection, Ogre::uint fsaa, Ogre::String const &fsaaHint)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader, bool hwGammaCorrection, Ogre::uint fsaa)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader, bool hwGammaCorrection)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, int num_mips, Ogre::PixelFormat format, int usage, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, int num_mips, Ogre::PixelFormat format, int usage)\n"
    "    Ogre::TexturePtr TextureManager.createManual(Ogre::String const &name, Ogre::String const &group, Ogre::TextureType texType, Ogre::uint width, Ogre::uint height, int num_mips, Ogre::PixelFormat format)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_setPreferredIntegerBitDepth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::ushort arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","setPreferredIntegerBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredIntegerBitDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setPreferredIntegerBitDepth", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setPreferredIntegerBitDepth(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_setPreferredIntegerBitDepth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","setPreferredIntegerBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredIntegerBitDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setPreferredIntegerBitDepth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_setPreferredIntegerBitDepth(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_Ogre__TextureManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureManager_setPreferredIntegerBitDepth__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureManager_setPreferredIntegerBitDepth__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureManager.setPreferredIntegerBitDepth", 
    "    void TextureManager.setPreferredIntegerBitDepth(Ogre::ushort bits, bool reloadTextures)\n"
    "    void TextureManager.setPreferredIntegerBitDepth(Ogre::ushort bits)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_getPreferredIntegerBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager const *","getPreferredIntegerBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  result = (Ogre::ushort)((Ogre::TextureManager const *)arg1)->getPreferredIntegerBitDepth();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_setPreferredFloatBitDepth__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::ushort arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","setPreferredFloatBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredFloatBitDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setPreferredFloatBitDepth", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setPreferredFloatBitDepth(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_setPreferredFloatBitDepth__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","setPreferredFloatBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredFloatBitDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setPreferredFloatBitDepth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_setPreferredFloatBitDepth(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_Ogre__TextureManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TextureManager_setPreferredFloatBitDepth__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureManager_setPreferredFloatBitDepth__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TextureManager.setPreferredFloatBitDepth", 
    "    void TextureManager.setPreferredFloatBitDepth(Ogre::ushort bits, bool reloadTextures)\n"
    "    void TextureManager.setPreferredFloatBitDepth(Ogre::ushort bits)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_getPreferredFloatBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager const *","getPreferredFloatBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  result = (Ogre::ushort)((Ogre::TextureManager const *)arg1)->getPreferredFloatBitDepth();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_setPreferredBitDepths__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::ushort arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","setPreferredBitDepths", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredBitDepths", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredBitDepths", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","setPreferredBitDepths", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->setPreferredBitDepths(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_setPreferredBitDepths__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::ushort arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","setPreferredBitDepths", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredBitDepths", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setPreferredBitDepths", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setPreferredBitDepths(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_setPreferredBitDepths(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_Ogre__TextureManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TextureManager_setPreferredBitDepths__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureManager_setPreferredBitDepths__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TextureManager.setPreferredBitDepths", 
    "    void TextureManager.setPreferredBitDepths(Ogre::ushort integerBits, Ogre::ushort floatBits, bool reloadTextures)\n"
    "    void TextureManager.setPreferredBitDepths(Ogre::ushort integerBits, Ogre::ushort floatBits)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_isFormatSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::TextureType arg2 ;
  Ogre::PixelFormat arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","isFormatSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureType","isFormatSupported", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::PixelFormat","isFormatSupported", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::PixelFormat >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","isFormatSupported", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->isFormatSupported(arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_isEquivalentFormatSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::TextureType arg2 ;
  Ogre::PixelFormat arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","isEquivalentFormatSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureType","isEquivalentFormatSupported", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::PixelFormat","isEquivalentFormatSupported", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::PixelFormat >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","isEquivalentFormatSupported", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->isEquivalentFormatSupported(arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_getNativeFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::TextureType arg2 ;
  Ogre::PixelFormat arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::PixelFormat 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","getNativeFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureType","getNativeFormat", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::PixelFormat","getNativeFormat", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::PixelFormat >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","getNativeFormat", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (Ogre::PixelFormat)(arg1)->getNativeFormat(arg2,arg3,arg4);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_isHardwareFilteringSupported__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::TextureType arg2 ;
  Ogre::PixelFormat arg3 ;
  int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool result;
  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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","isHardwareFilteringSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureType","isHardwareFilteringSupported", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::PixelFormat","isHardwareFilteringSupported", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::PixelFormat >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","isHardwareFilteringSupported", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","isHardwareFilteringSupported", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (bool)(arg1)->isHardwareFilteringSupported(arg2,arg3,arg4,arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_isHardwareFilteringSupported__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  Ogre::TextureType arg2 ;
  Ogre::PixelFormat arg3 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","isHardwareFilteringSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureType","isHardwareFilteringSupported", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::PixelFormat","isHardwareFilteringSupported", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::PixelFormat >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","isHardwareFilteringSupported", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (bool)(arg1)->isHardwareFilteringSupported(arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TextureManager_isHardwareFilteringSupported(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TextureManager_isHardwareFilteringSupported__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureManager, 0);
    _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) {
          {
            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_TextureManager_isHardwareFilteringSupported__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TextureManager.isHardwareFilteringSupported", 
    "    bool TextureManager.isHardwareFilteringSupported(Ogre::TextureType ttype, Ogre::PixelFormat format, int usage, bool preciseFormatOnly)\n"
    "    bool TextureManager.isHardwareFilteringSupported(Ogre::TextureType ttype, Ogre::PixelFormat format, int usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_setDefaultNumMipmaps(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","setDefaultNumMipmaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setDefaultNumMipmaps", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setDefaultNumMipmaps(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_getDefaultNumMipmaps(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *arg1 = (Ogre::TextureManager *) 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_Ogre__TextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureManager *","getDefaultNumMipmaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureManager * >(argp1);
  result = (arg1)->getDefaultNumMipmaps();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TextureManager *) &Ogre::TextureManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TextureManager *)Ogre::TextureManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassViewport;

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

SWIGINTERN VALUE
_wrap_new_Viewport(int argc, VALUE *argv, VALUE self) {
  Ogre::Camera *arg1 = (Ogre::Camera *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Viewport";
  Ogre::Viewport *result = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Camera *","Ogre::Viewport", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Camera * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","Ogre::Viewport", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Viewport", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Viewport", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Viewport", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::Viewport", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","Ogre::Viewport", 7, argv[6] ));
  } 
  arg7 = static_cast< int >(val7);
  result = (Ogre::Viewport *)new Ogre::Viewport(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Viewport(Ogre::Viewport *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Viewport__updateDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","_updateDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  (arg1)->_updateDimensions();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_update(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  (arg1)->update();
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Viewport.clear

  call-seq:
    clear(buffers=Ogre::FBT_COLOUR|Ogre::FBT_DEPTH, colour=Black, 
    depth=1.0, stencil=0)
    clear(buffers=Ogre::FBT_COLOUR|Ogre::FBT_DEPTH, colour=Black, 
    depth=1.0)
    clear(buffers=Ogre::FBT_COLOUR|Ogre::FBT_DEPTH, colour=Black)
    clear(buffers=Ogre::FBT_COLOUR|Ogre::FBT_DEPTH)
    clear

Clear Viewport contents.
*/
SWIGINTERN VALUE
_wrap_Viewport_clear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  unsigned int arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  unsigned short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(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","clear", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","clear", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","clear", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","clear", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned short","clear", 5, argv[3] ));
  } 
  arg5 = static_cast< unsigned short >(val5);
  (arg1)->clear(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_clear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  unsigned int arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(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","clear", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","clear", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","clear", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","clear", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->clear(arg2,(Ogre::ColourValue const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_clear__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  unsigned int arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(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","clear", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","clear", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","clear", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->clear(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_clear__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(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","clear", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->clear(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_clear__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Viewport_clear(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Viewport_clear__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Viewport_clear__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Viewport_clear__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Viewport_clear__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Viewport_clear__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Viewport.clear", 
    "    void Viewport.clear(unsigned int buffers, Ogre::ColourValue const &colour, Ogre::Real depth, unsigned short stencil)\n"
    "    void Viewport.clear(unsigned int buffers, Ogre::ColourValue const &colour, Ogre::Real depth)\n"
    "    void Viewport.clear(unsigned int buffers, Ogre::ColourValue const &colour)\n"
    "    void Viewport.clear(unsigned int buffers)\n"
    "    void Viewport.clear()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderTarget *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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::RenderTarget *)((Ogre::Viewport const *)arg1)->getTarget();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Camera *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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::Camera *)((Ogre::Viewport const *)arg1)->getCamera();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","setCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->setCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (int)((Ogre::Viewport const *)arg1)->getZOrder();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getLeft();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getTop(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getTop();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getActualLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getActualLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (int)((Ogre::Viewport const *)arg1)->getActualLeft();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getActualTop(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getActualTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (int)((Ogre::Viewport const *)arg1)->getActualTop();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getActualWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getActualWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (int)((Ogre::Viewport const *)arg1)->getActualWidth();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getActualHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getActualHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (int)((Ogre::Viewport const *)arg1)->getActualHeight();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDimensions", 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","setDimensions", 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","setDimensions", 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","setDimensions", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setDimensions(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setOrientationMode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::OrientationMode arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setOrientationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::OrientationMode","setOrientationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::OrientationMode >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setOrientationMode", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setOrientationMode(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setOrientationMode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::OrientationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setOrientationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::OrientationMode","setOrientationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::OrientationMode >(val2);
  (arg1)->setOrientationMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Viewport_setOrientationMode(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_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Viewport_setOrientationMode__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Viewport_setOrientationMode__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Viewport.setOrientationMode", 
    "    void Viewport.setOrientationMode(Ogre::OrientationMode orientationMode, bool setDefault)\n"
    "    void Viewport.setOrientationMode(Ogre::OrientationMode orientationMode)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getOrientationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::OrientationMode 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getOrientationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::OrientationMode)((Ogre::Viewport const *)arg1)->getOrientationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setDefaultOrientationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::OrientationMode arg1 ;
  int val1 ;
  int ecode1 = 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( "", "Ogre::OrientationMode","Ogre::Viewport::setDefaultOrientationMode", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::OrientationMode >(val1);
  Ogre::Viewport::setDefaultOrientationMode(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getDefaultOrientationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::OrientationMode result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OrientationMode)Ogre::Viewport::getDefaultOrientationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setBackgroundColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::ColourValue *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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setBackgroundColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setBackgroundColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setBackgroundColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setBackgroundColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getBackgroundColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getBackgroundColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Viewport const *)arg1)->getBackgroundColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setDepthClear(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setDepthClear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDepthClear", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDepthClear(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getDepthClear(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getDepthClear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::Real)((Ogre::Viewport const *)arg1)->getDepthClear();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setClearEveryFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  bool arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setClearEveryFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setClearEveryFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(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","setClearEveryFrame", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->setClearEveryFrame(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setClearEveryFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setClearEveryFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setClearEveryFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setClearEveryFrame(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Viewport_setClearEveryFrame(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_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Viewport_setClearEveryFrame__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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) {
          return _wrap_Viewport_setClearEveryFrame__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Viewport.setClearEveryFrame", 
    "    void Viewport.setClearEveryFrame(bool clear, unsigned int buffers)\n"
    "    void Viewport.setClearEveryFrame(bool clear)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getClearEveryFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getClearEveryFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (bool)((Ogre::Viewport const *)arg1)->getClearEveryFrame();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getClearBuffers(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getClearBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (unsigned int)((Ogre::Viewport const *)arg1)->getClearBuffers();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setAutoUpdated(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setAutoUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoUpdated", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoUpdated(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_isAutoUpdated(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","isAutoUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (bool)((Ogre::Viewport const *)arg1)->isAutoUpdated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setMaterialScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setMaterialScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(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( "", "Ogre::String const &","setMaterialScheme", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialScheme", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialScheme((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getMaterialScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getMaterialScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::String *) &((Ogre::Viewport const *)arg1)->getMaterialScheme();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getActualDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  int *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getActualDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int &","getActualDimensions", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getActualDimensions", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int &","getActualDimensions", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getActualDimensions", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int &","getActualDimensions", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getActualDimensions", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int &","getActualDimensions", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getActualDimensions", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  ((Ogre::Viewport const *)arg1)->getActualDimensions(*arg2,*arg3,*arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport__isUpdated(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","_isUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (bool)((Ogre::Viewport const *)arg1)->_isUpdated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport__clearUpdatedFlag(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","_clearUpdatedFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  (arg1)->_clearUpdatedFlag();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport__getNumRenderedFaces(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","_getNumRenderedFaces", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (unsigned int)((Ogre::Viewport const *)arg1)->_getNumRenderedFaces();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport__getNumRenderedBatches(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","_getNumRenderedBatches", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (unsigned int)((Ogre::Viewport const *)arg1)->_getNumRenderedBatches();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setOverlaysEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setOverlaysEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setOverlaysEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setOverlaysEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getOverlaysEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getOverlaysEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (bool)((Ogre::Viewport const *)arg1)->getOverlaysEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setSkiesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setSkiesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkiesEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSkiesEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getSkiesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getSkiesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (bool)((Ogre::Viewport const *)arg1)->getSkiesEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setShadowsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setShadowsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowsEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowsEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getShadowsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getShadowsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (bool)((Ogre::Viewport const *)arg1)->getShadowsEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setVisibilityMask(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::uint32 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setVisibilityMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setVisibilityMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setVisibilityMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getVisibilityMask(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getVisibilityMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::uint)((Ogre::Viewport const *)arg1)->getVisibilityMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_setRenderQueueInvocationSequenceName(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","setRenderQueueInvocationSequenceName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(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( "", "Ogre::String const &","setRenderQueueInvocationSequenceName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setRenderQueueInvocationSequenceName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setRenderQueueInvocationSequenceName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_getRenderQueueInvocationSequenceName(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getRenderQueueInvocationSequenceName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::String *) &((Ogre::Viewport const *)arg1)->getRenderQueueInvocationSequenceName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport__getRenderQueueInvocationSequence(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderQueueInvocationSequence *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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","_getRenderQueueInvocationSequence", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::RenderQueueInvocationSequence *)(arg1)->_getRenderQueueInvocationSequence();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_pointOrientedToScreen__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  int arg3 ;
  Ogre::Vector2 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","pointOrientedToScreen", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(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 &","pointOrientedToScreen", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","pointOrientedToScreen", 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( "", "int","pointOrientedToScreen", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  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 &","pointOrientedToScreen", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 &","pointOrientedToScreen", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector2 * >(argp4);
  (arg1)->pointOrientedToScreen((Ogre::Vector2 const &)*arg2,arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_pointOrientedToScreen__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  int arg4 ;
  Ogre::Real *arg5 = 0 ;
  Ogre::Real *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","pointOrientedToScreen", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","pointOrientedToScreen", 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","pointOrientedToScreen", 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( "", "int","pointOrientedToScreen", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real &","pointOrientedToScreen", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","pointOrientedToScreen", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Real &","pointOrientedToScreen", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","pointOrientedToScreen", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Real * >(argp6);
  (arg1)->pointOrientedToScreen(arg2,arg3,arg4,*arg5,*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Viewport_pointOrientedToScreen(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector2, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Viewport_pointOrientedToScreen__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Viewport, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_float, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Viewport_pointOrientedToScreen__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Viewport.pointOrientedToScreen", 
    "    void Viewport.pointOrientedToScreen(Ogre::Vector2 const &v, int orientationMode, Ogre::Vector2 &outv)\n"
    "    void Viewport.pointOrientedToScreen(Ogre::Real orientedX, Ogre::Real orientedY, int orientationMode, Ogre::Real &screenX, Ogre::Real &screenY)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::Viewport::Listener *arg2 = (Ogre::Viewport::Listener *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Viewport_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  Ogre::Viewport::Listener *arg2 = (Ogre::Viewport::Listener *) 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_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderTarget;

SWIGINTERN void
free_Ogre_RenderTarget(Ogre::RenderTarget *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderTarget_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::String *) &((Ogre::RenderTarget const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getMetrics(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int *arg3 = 0 ;
  unsigned int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","getMetrics", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned int &","getMetrics", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned int &","getMetrics", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "unsigned int &","getMetrics", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned int &","getMetrics", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< unsigned int * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "unsigned int &","getMetrics", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned int &","getMetrics", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< unsigned int * >(argp4);
  (arg1)->getMetrics(*arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (unsigned int)((Ogre::RenderTarget const *)arg1)->getWidth();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (unsigned int)((Ogre::RenderTarget const *)arg1)->getHeight();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getColourDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getColourDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (unsigned int)((Ogre::RenderTarget const *)arg1)->getColourDepth();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_setDepthBufferPool(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","setDepthBufferPool", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setDepthBufferPool", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setDepthBufferPool(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getDepthBufferPool(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getDepthBufferPool", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::uint16)((Ogre::RenderTarget const *)arg1)->getDepthBufferPool();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getDepthBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::DepthBuffer *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getDepthBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::DepthBuffer *)((Ogre::RenderTarget const *)arg1)->getDepthBuffer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DepthBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_attachDepthBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::DepthBuffer *arg2 = (Ogre::DepthBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","attachDepthBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DepthBuffer *","attachDepthBuffer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::DepthBuffer * >(argp2);
  result = (bool)(arg1)->attachDepthBuffer(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_detachDepthBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","detachDepthBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->detachDepthBuffer();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__detachDepthBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_detachDepthBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->_detachDepthBuffer();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_update__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","update", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->update(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_update__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->update();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_update(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_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderTarget_update__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderTarget_update__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderTarget.update", 
    "    void RenderTarget.update(bool swapBuffers)\n"
    "    void RenderTarget.update()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_swapBuffers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","swapBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","swapBuffers", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->swapBuffers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_swapBuffers__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","swapBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->swapBuffers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_swapBuffers(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_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderTarget_swapBuffers__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderTarget_swapBuffers__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderTarget.swapBuffers", 
    "    void RenderTarget.swapBuffers(bool waitForVSync)\n"
    "    void RenderTarget.swapBuffers()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_addViewport__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  int arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  float arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  Ogre::Viewport *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","addViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","addViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addViewport", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","addViewport", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "float","addViewport", 5, argv[3] ));
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "float","addViewport", 6, argv[4] ));
  } 
  arg6 = static_cast< float >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "float","addViewport", 7, argv[5] ));
  } 
  arg7 = static_cast< float >(val7);
  result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_addViewport__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  int arg3 ;
  float arg4 ;
  float arg5 ;
  float arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  Ogre::Viewport *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","addViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","addViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addViewport", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","addViewport", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "float","addViewport", 5, argv[3] ));
  } 
  arg5 = static_cast< float >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "float","addViewport", 6, argv[4] ));
  } 
  arg6 = static_cast< float >(val6);
  result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_addViewport__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  int arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  Ogre::Viewport *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","addViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","addViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addViewport", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","addViewport", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "float","addViewport", 5, argv[3] ));
  } 
  arg5 = static_cast< float >(val5);
  result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_addViewport__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  int arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Ogre::Viewport *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","addViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","addViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addViewport", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","addViewport", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_addViewport__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Ogre::Viewport *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","addViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","addViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","addViewport", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (Ogre::Viewport *)(arg1)->addViewport(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_addViewport__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::Viewport *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","addViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","addViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Viewport *)(arg1)->addViewport(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_addViewport(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RenderTarget_addViewport__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderTarget_addViewport__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(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_RenderTarget_addViewport__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(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_RenderTarget_addViewport__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_RenderTarget_addViewport__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_RenderTarget_addViewport__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderTarget.addViewport", 
    "    Ogre::Viewport * RenderTarget.addViewport(Ogre::Camera *cam, int ZOrder, float left, float top, float width, float height)\n"
    "    Ogre::Viewport * RenderTarget.addViewport(Ogre::Camera *cam, int ZOrder, float left, float top, float width)\n"
    "    Ogre::Viewport * RenderTarget.addViewport(Ogre::Camera *cam, int ZOrder, float left, float top)\n"
    "    Ogre::Viewport * RenderTarget.addViewport(Ogre::Camera *cam, int ZOrder, float left)\n"
    "    Ogre::Viewport * RenderTarget.addViewport(Ogre::Camera *cam, int ZOrder)\n"
    "    Ogre::Viewport * RenderTarget.addViewport(Ogre::Camera *cam)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getNumViewports(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getNumViewports", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (unsigned short)((Ogre::RenderTarget const *)arg1)->getNumViewports();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Viewport *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","getViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(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","getViewport", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Viewport *)(arg1)->getViewport(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getViewportByZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::Viewport *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","getViewportByZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","getViewportByZOrder", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (Ogre::Viewport *)(arg1)->getViewportByZOrder(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_hasViewportWithZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","hasViewportWithZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","hasViewportWithZOrder", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  result = (bool)(arg1)->hasViewportWithZOrder(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_removeViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","removeViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","removeViewport", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->removeViewport(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_removeAllViewports(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","removeAllViewports", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->removeAllViewports();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getStatistics__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  float *arg2 = 0 ;
  float *arg3 = 0 ;
  float *arg4 = 0 ;
  float *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getStatistics", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float &","getStatistics", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "float &","getStatistics", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float &","getStatistics", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "float &","getStatistics", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float &","getStatistics", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "float &","getStatistics", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "float &","getStatistics", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "float &","getStatistics", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< float * >(argp5);
  ((Ogre::RenderTarget const *)arg1)->getStatistics(*arg2,*arg3,*arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getStatistics__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderTarget::FrameStats *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getStatistics", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::RenderTarget::FrameStats *) &((Ogre::RenderTarget const *)arg1)->getStatistics();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget__FrameStats, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_getStatistics(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderTarget_getStatistics__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_float, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_float, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_RenderTarget_getStatistics__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderTarget.getStatistics", 
    "    Ogre::RenderTarget::FrameStats const & RenderTarget.getStatistics(float &lastFPS, float &avgFPS, float &bestFPS, float &worstFPS)\n"
    "    Ogre::RenderTarget::FrameStats const & RenderTarget.getStatistics()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getLastFPS(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getLastFPS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (float)((Ogre::RenderTarget const *)arg1)->getLastFPS();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getAverageFPS(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getAverageFPS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (float)((Ogre::RenderTarget const *)arg1)->getAverageFPS();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getBestFPS(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getBestFPS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (float)((Ogre::RenderTarget const *)arg1)->getBestFPS();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getWorstFPS(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getWorstFPS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (float)((Ogre::RenderTarget const *)arg1)->getWorstFPS();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getBestFrameTime(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getBestFrameTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (float)((Ogre::RenderTarget const *)arg1)->getBestFrameTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getWorstFrameTime(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getWorstFrameTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (float)((Ogre::RenderTarget const *)arg1)->getWorstFrameTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_resetStatistics(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","resetStatistics", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->resetStatistics();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getCustomAttribute(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 ;
  
  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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","getCustomAttribute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(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( "", "Ogre::String const &","getCustomAttribute", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getCustomAttribute", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","getCustomAttribute", 3, argv[1] )); 
  }
  (arg1)->getCustomAttribute((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::RenderTargetListener *arg2 = (Ogre::RenderTargetListener *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetListener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::RenderTargetListener *arg2 = (Ogre::RenderTargetListener *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetListener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_removeAllListeners(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","removeAllListeners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->removeAllListeners();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_setPriority(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::uchar arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","setPriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uchar","setPriority", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uchar >(val2);
  (arg1)->setPriority(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getPriority(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uchar 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getPriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::uchar)((Ogre::RenderTarget const *)arg1)->getPriority();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_isActive(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","isActive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (bool)((Ogre::RenderTarget const *)arg1)->isActive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_setActive(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","setActive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setActive", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setActive(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_setAutoUpdated(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","setAutoUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoUpdated", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoUpdated(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_isAutoUpdated(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","isAutoUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (bool)((Ogre::RenderTarget const *)arg1)->isAutoUpdated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_copyContentsToMemory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  Ogre::RenderTarget::FrameBuffer arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","copyContentsToMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::RenderTarget::FrameBuffer","copyContentsToMemory", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::RenderTarget::FrameBuffer >(val3);
  (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_copyContentsToMemory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::PixelBox *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","copyContentsToMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget_copyContentsToMemory(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_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RenderTarget_copyContentsToMemory__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderTarget_copyContentsToMemory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderTarget.copyContentsToMemory", 
    "    void RenderTarget.copyContentsToMemory(Ogre::PixelBox const &dst, Ogre::RenderTarget::FrameBuffer buffer)\n"
    "    void RenderTarget.copyContentsToMemory(Ogre::PixelBox const &dst)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_suggestPixelFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","suggestPixelFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::RenderTarget const *)arg1)->suggestPixelFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_writeContentsToFile(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","writeContentsToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(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( "", "Ogre::String const &","writeContentsToFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeContentsToFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->writeContentsToFile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_writeContentsToTimestampedFile(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","writeContentsToTimestampedFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(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( "", "Ogre::String const &","writeContentsToTimestampedFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeContentsToTimestampedFile", 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 &","writeContentsToTimestampedFile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeContentsToTimestampedFile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->writeContentsToTimestampedFile((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  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_RenderTarget_requiresTextureFlipping(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","requiresTextureFlipping", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (bool)((Ogre::RenderTarget const *)arg1)->requiresTextureFlipping();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getTriangleCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getTriangleCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = ((Ogre::RenderTarget const *)arg1)->getTriangleCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getBatchCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getBatchCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = ((Ogre::RenderTarget const *)arg1)->getBatchCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__notifyCameraRemoved(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_notifyCameraRemoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","_notifyCameraRemoved", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCameraRemoved((Ogre::Camera const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_isPrimary(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","isPrimary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (bool)((Ogre::RenderTarget const *)arg1)->isPrimary();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_isHardwareGammaEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","isHardwareGammaEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (bool)((Ogre::RenderTarget const *)arg1)->isHardwareGammaEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getFSAA(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getFSAA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::uint)((Ogre::RenderTarget const *)arg1)->getFSAA();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget_getFSAAHint(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget const *","getFSAAHint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::String *) &((Ogre::RenderTarget const *)arg1)->getFSAAHint();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__getImpl(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderTarget::Impl *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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_getImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  result = (Ogre::RenderTarget::Impl *)(arg1)->_getImpl();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget__Impl, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__beginUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_beginUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->_beginUpdate();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__updateViewport__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  int arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_updateViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","_updateViewport", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_updateViewport", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_updateViewport(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__updateViewport__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_updateViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","_updateViewport", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->_updateViewport(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__updateViewport__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_updateViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","_updateViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_updateViewport", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_updateViewport(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__updateViewport__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_updateViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","_updateViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->_updateViewport(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget__updateViewport(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_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RenderTarget__updateViewport__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderTarget__updateViewport__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderTarget__updateViewport__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderTarget__updateViewport__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderTarget._updateViewport", 
    "    void RenderTarget._updateViewport(int zorder, bool updateStatistics)\n"
    "    void RenderTarget._updateViewport(int zorder)\n"
    "    void RenderTarget._updateViewport(Ogre::Viewport *viewport, bool updateStatistics)\n"
    "    void RenderTarget._updateViewport(Ogre::Viewport *viewport)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__updateAutoUpdatedViewports__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_updateAutoUpdatedViewports", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_updateAutoUpdatedViewports", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_updateAutoUpdatedViewports(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__updateAutoUpdatedViewports__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_updateAutoUpdatedViewports", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->_updateAutoUpdatedViewports();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderTarget__updateAutoUpdatedViewports(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_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderTarget__updateAutoUpdatedViewports__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderTarget__updateAutoUpdatedViewports__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderTarget._updateAutoUpdatedViewports", 
    "    void RenderTarget._updateAutoUpdatedViewports(bool updateStatistics)\n"
    "    void RenderTarget._updateAutoUpdatedViewports()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTarget__endUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTarget *arg1 = (Ogre::RenderTarget *) 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_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_endUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTarget * >(argp1);
  (arg1)->_endUpdate();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderTexture;

SWIGINTERN void
free_Ogre_RenderTexture(Ogre::RenderTexture *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderTexture_copyContentsToMemory(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTexture *arg1 = (Ogre::RenderTexture *) 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  Ogre::RenderTarget::FrameBuffer arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__RenderTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTexture *","copyContentsToMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTexture * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::RenderTarget::FrameBuffer","copyContentsToMemory", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::RenderTarget::FrameBuffer >(val3);
  (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTexture_suggestPixelFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTexture *arg1 = (Ogre::RenderTexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__RenderTexture, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTexture const *","suggestPixelFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTexture * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::RenderTexture const *)arg1)->suggestPixelFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMultiRenderTarget;

SWIGINTERN VALUE
_wrap_MultiRenderTarget_bindSurface(int argc, VALUE *argv, VALUE self) {
  Ogre::MultiRenderTarget *arg1 = (Ogre::MultiRenderTarget *) 0 ;
  size_t arg2 ;
  Ogre::RenderTexture *arg3 = (Ogre::RenderTexture *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__MultiRenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MultiRenderTarget *","bindSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MultiRenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","bindSurface", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderTexture, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderTexture *","bindSurface", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderTexture * >(argp3);
  (arg1)->bindSurface(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiRenderTarget_unbindSurface(int argc, VALUE *argv, VALUE self) {
  Ogre::MultiRenderTarget *arg1 = (Ogre::MultiRenderTarget *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__MultiRenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MultiRenderTarget *","unbindSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MultiRenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","unbindSurface", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->unbindSurface(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiRenderTarget_copyContentsToMemory(int argc, VALUE *argv, VALUE self) {
  Ogre::MultiRenderTarget *arg1 = (Ogre::MultiRenderTarget *) 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  Ogre::RenderTarget::FrameBuffer arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__MultiRenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MultiRenderTarget *","copyContentsToMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MultiRenderTarget * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","copyContentsToMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::RenderTarget::FrameBuffer","copyContentsToMemory", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::RenderTarget::FrameBuffer >(val3);
  (arg1)->copyContentsToMemory((Ogre::PixelBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiRenderTarget_suggestPixelFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::MultiRenderTarget *arg1 = (Ogre::MultiRenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__MultiRenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MultiRenderTarget const *","suggestPixelFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MultiRenderTarget * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::MultiRenderTarget const *)arg1)->suggestPixelFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiRenderTarget_getBoundSurfaceList(int argc, VALUE *argv, VALUE self) {
  Ogre::MultiRenderTarget *arg1 = (Ogre::MultiRenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MultiRenderTarget::BoundSufaceList *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_Ogre__MultiRenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MultiRenderTarget const *","getBoundSurfaceList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MultiRenderTarget * >(argp1);
  result = (Ogre::MultiRenderTarget::BoundSufaceList *) &((Ogre::MultiRenderTarget const *)arg1)->getBoundSurfaceList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MultiRenderTarget_getBoundSurface(int argc, VALUE *argv, VALUE self) {
  Ogre::MultiRenderTarget *arg1 = (Ogre::MultiRenderTarget *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::RenderTexture *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_Ogre__MultiRenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MultiRenderTarget *","getBoundSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MultiRenderTarget * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getBoundSurface", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::RenderTexture *)(arg1)->getBoundSurface(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTexture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MultiRenderTarget(Ogre::MultiRenderTarget *arg1) {
    delete arg1;
}

swig_class SwigClassFrameEvent;

SWIGINTERN VALUE
_wrap_FrameEvent_timeSinceLastEvent_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameEvent *arg1 = (Ogre::FrameEvent *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__FrameEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameEvent *","timeSinceLastEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameEvent * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","timeSinceLastEvent", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->timeSinceLastEvent = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameEvent_timeSinceLastEvent_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameEvent *arg1 = (Ogre::FrameEvent *) 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_Ogre__FrameEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameEvent *","timeSinceLastEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameEvent * >(argp1);
  result = (Ogre::Real) ((arg1)->timeSinceLastEvent);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameEvent_timeSinceLastFrame_set(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameEvent *arg1 = (Ogre::FrameEvent *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__FrameEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameEvent *","timeSinceLastFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameEvent * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","timeSinceLastFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->timeSinceLastFrame = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameEvent_timeSinceLastFrame_get(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameEvent *arg1 = (Ogre::FrameEvent *) 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_Ogre__FrameEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameEvent *","timeSinceLastFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameEvent * >(argp1);
  result = (Ogre::Real) ((arg1)->timeSinceLastFrame);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_FrameEvent(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::FrameEvent";
  Ogre::FrameEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FrameEvent *)new Ogre::FrameEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FrameEvent(Ogre::FrameEvent *arg1) {
    delete arg1;
}

swig_class SwigClassFrameListener;

SWIGINTERN VALUE
_wrap_FrameListener_frameStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameListener *arg1 = (Ogre::FrameListener *) 0 ;
  Ogre::FrameEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  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_Ogre__FrameListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameListener *","frameStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent const &","frameStarted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent const &","frameStarted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      result = (bool)(arg1)->Ogre::FrameListener::frameStarted((Ogre::FrameEvent const &)*arg2);
    } else {
      result = (bool)(arg1)->frameStarted((Ogre::FrameEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameListener_frameRenderingQueued(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameListener *arg1 = (Ogre::FrameListener *) 0 ;
  Ogre::FrameEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  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_Ogre__FrameListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameListener *","frameRenderingQueued", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent const &","frameRenderingQueued", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent const &","frameRenderingQueued", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      result = (bool)(arg1)->Ogre::FrameListener::frameRenderingQueued((Ogre::FrameEvent const &)*arg2);
    } else {
      result = (bool)(arg1)->frameRenderingQueued((Ogre::FrameEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameListener_frameEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameListener *arg1 = (Ogre::FrameListener *) 0 ;
  Ogre::FrameEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  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_Ogre__FrameListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameListener *","frameEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent const &","frameEnded", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent const &","frameEnded", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      result = (bool)(arg1)->Ogre::FrameListener::frameEnded((Ogre::FrameEvent const &)*arg2);
    } else {
      result = (bool)(arg1)->frameEnded((Ogre::FrameEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FrameListener(Ogre::FrameListener *arg1) {
    delete arg1;
}

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

SWIGINTERN VALUE
_wrap_new_FrameListener(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  const char *classname SWIGUNUSED = "Ogre::FrameListener";
  Ogre::FrameListener *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  arg1 = self;
  if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
    /* subclassed */
    result = (Ogre::FrameListener *)new SwigDirector_FrameListener(arg1); 
  } else {
    result = (Ogre::FrameListener *)new Ogre::FrameListener(); 
  }
  
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_disown_FrameListener(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameListener *arg1 = (Ogre::FrameListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__FrameListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameListener *","disown_FrameListener", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameListener * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassConfigOption;

SWIGINTERN VALUE
_wrap_ConfigOption_name_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 0 ;
  Ogre::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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(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( "", "Ogre::String const &","name", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","name", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigOption_name_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(argp1);
  result = (Ogre::String *) & ((arg1)->name);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigOption_currentValue_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 0 ;
  Ogre::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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","currentValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(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( "", "Ogre::String const &","currentValue", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","currentValue", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->currentValue = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigOption_currentValue_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","currentValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(argp1);
  result = (Ogre::String *) & ((arg1)->currentValue);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigOption_possibleValues_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 0 ;
  Ogre::StringVector *arg2 = (Ogre::StringVector *) 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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","possibleValues", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringVector *","possibleValues", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::StringVector * >(argp2);
  if (arg1) (arg1)->possibleValues = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigOption_possibleValues_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","possibleValues", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(argp1);
  result = (Ogre::StringVector *)& ((arg1)->possibleValues);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigOption_immutable_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","immutable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","immutable", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->immutable = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigOption_immutable_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigOption *arg1 = (Ogre::ConfigOption *) 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_Ogre___ConfigOption, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigOption *","immutable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigOption * >(argp1);
  result = (bool) ((arg1)->immutable);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ConfigOption(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ConfigOption";
  Ogre::ConfigOption *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ConfigOption *)new Ogre::ConfigOption();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ConfigOption(Ogre::ConfigOption *arg1) {
    delete arg1;
}

swig_class SwigClassRenderSystem;

SWIGINTERN void
free_Ogre_RenderSystem(Ogre::RenderSystem *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderSystem_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::String *) &((Ogre::RenderSystem const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getConfigOptions(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ConfigOptionMap *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getConfigOptions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::ConfigOptionMap *) &(arg1)->getConfigOptions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), 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, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setConfigOption(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setConfigOption", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","setConfigOption", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setConfigOption", 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 &","setConfigOption", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setConfigOption", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setConfigOption((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_createHardwareOcclusionQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareOcclusionQuery *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","createHardwareOcclusionQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::HardwareOcclusionQuery *)(arg1)->createHardwareOcclusionQuery();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareOcclusionQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_destroyHardwareOcclusionQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::HardwareOcclusionQuery *arg2 = (Ogre::HardwareOcclusionQuery *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","destroyHardwareOcclusionQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareOcclusionQuery, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareOcclusionQuery *","destroyHardwareOcclusionQuery", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareOcclusionQuery * >(argp2);
  (arg1)->destroyHardwareOcclusionQuery(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_validateConfigOptions(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","validateConfigOptions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (arg1)->validateConfigOptions();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__initialise__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::RenderWindow *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_initialise", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_initialise", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_initialise", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::RenderWindow *)(arg1)->_initialise(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__initialise__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::RenderWindow *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_initialise", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::RenderWindow *)(arg1)->_initialise(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__initialise(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__initialise__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _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_RenderSystem__initialise__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderSystem._initialise", 
    "    Ogre::RenderWindow * RenderSystem._initialise(bool autoCreateWindow, Ogre::String const &windowTitle)\n"
    "    Ogre::RenderWindow * RenderSystem._initialise(bool autoCreateWindow)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_createRenderSystemCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystemCapabilities *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","createRenderSystemCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::RenderSystemCapabilities *)((Ogre::RenderSystem const *)arg1)->createRenderSystemCapabilities();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getMutableCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystemCapabilities *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getMutableCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::RenderSystemCapabilities *)(arg1)->getMutableCapabilities();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_useCustomRenderSystemCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderSystemCapabilities *arg2 = (Ogre::RenderSystemCapabilities *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","useCustomRenderSystemCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","useCustomRenderSystemCapabilities", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp2);
  (arg1)->useCustomRenderSystemCapabilities(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_reinitialise(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","reinitialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->reinitialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_shutdown(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","shutdown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->shutdown();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setAmbientLight(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  float arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setAmbientLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setAmbientLight", 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","setAmbientLight", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","setAmbientLight", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setAmbientLight(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setShadingType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::ShadeOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setShadingType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadeOptions","setShadingType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadeOptions >(val2);
  (arg1)->setShadingType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setLightingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setLightingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLightingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLightingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setWBufferEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setWBufferEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setWBufferEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setWBufferEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getWBufferEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getWBufferEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (bool)((Ogre::RenderSystem const *)arg1)->getWBufferEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__createRenderWindow__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bool arg5 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Ogre::RenderWindow *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_createRenderWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","_createRenderWindow", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_createRenderWindow", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","_createRenderWindow", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(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","_createRenderWindow", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_createRenderWindow", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","_createRenderWindow", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (Ogre::RenderWindow *)(arg1)->_createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__createRenderWindow__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::RenderWindow *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_createRenderWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","_createRenderWindow", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_createRenderWindow", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","_createRenderWindow", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(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","_createRenderWindow", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_createRenderWindow", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::RenderWindow *)(arg1)->_createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__createRenderWindow(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_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_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RenderSystem__createRenderWindow__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_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_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_RenderSystem__createRenderWindow__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RenderSystem._createRenderWindow", 
    "    Ogre::RenderWindow * RenderSystem._createRenderWindow(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen, Ogre::NameValuePairList const *miscParams)\n"
    "    Ogre::RenderWindow * RenderSystem._createRenderWindow(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__createRenderWindows(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderWindowDescriptionList *arg2 = 0 ;
  Ogre::RenderWindowList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_createRenderWindows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescriptionList const &","_createRenderWindows", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderWindowDescriptionList const &","_createRenderWindows", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderWindowDescriptionList * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderWindowList &","_createRenderWindows", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderWindowList &","_createRenderWindows", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::RenderWindowList * >(argp3);
  result = (bool)(arg1)->_createRenderWindows((Ogre::RenderWindowDescriptionList const &)*arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_createMultiRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MultiRenderTarget *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","createMultiRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","createMultiRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMultiRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::MultiRenderTarget *)(arg1)->createMultiRenderTarget((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MultiRenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_destroyRenderWindow(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","destroyRenderWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","destroyRenderWindow", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyRenderWindow", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyRenderWindow((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_destroyRenderTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","destroyRenderTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","destroyRenderTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyRenderTexture", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyRenderTexture((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_destroyRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","destroyRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","destroyRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyRenderTarget((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_attachRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderTarget *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","attachRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTarget,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget &","attachRenderTarget", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTarget &","attachRenderTarget", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  (arg1)->attachRenderTarget(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderTarget *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","getRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_detachRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderTarget *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","detachRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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( "", "Ogre::String const &","detachRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","detachRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderTarget *)(arg1)->detachRenderTarget((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getRenderTargetIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::RenderTarget *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::RenderTarget * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getRenderTargetIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (arg1)->getRenderTargetIterator();
  vresult = SWIG_NewPointerObj((new Ogre::RenderSystem::RenderTargetIterator(static_cast< const Ogre::RenderSystem::RenderTargetIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_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_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getErrorDescription(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getErrorDescription", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getErrorDescription", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  result = ((Ogre::RenderSystem const *)arg1)->getErrorDescription(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setWaitForVerticalBlank(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setWaitForVerticalBlank", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setWaitForVerticalBlank", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setWaitForVerticalBlank(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getWaitForVerticalBlank(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getWaitForVerticalBlank", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (bool)((Ogre::RenderSystem const *)arg1)->getWaitForVerticalBlank();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getGlobalInstanceVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getGlobalInstanceVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = ((Ogre::RenderSystem const *)arg1)->getGlobalInstanceVertexBuffer();
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setGlobalInstanceVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr arg2 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setGlobalInstanceVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const","setGlobalInstanceVertexBuffer", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const","setGlobalInstanceVertexBuffer", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2));
    }
  }
  (arg1)->setGlobalInstanceVertexBuffer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getGlobalInstanceVertexBufferVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getGlobalInstanceVertexBufferVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::VertexDeclaration *)((Ogre::RenderSystem const *)arg1)->getGlobalInstanceVertexBufferVertexDeclaration();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setGlobalInstanceVertexBufferVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setGlobalInstanceVertexBufferVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","setGlobalInstanceVertexBufferVertexDeclaration", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  (arg1)->setGlobalInstanceVertexBufferVertexDeclaration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getGlobalNumberOfInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getGlobalNumberOfInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = ((Ogre::RenderSystem const *)arg1)->getGlobalNumberOfInstances();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setGlobalNumberOfInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setGlobalNumberOfInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setGlobalNumberOfInstances", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setGlobalNumberOfInstances(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setFixedPipelineEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setFixedPipelineEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFixedPipelineEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFixedPipelineEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getFixedPipelineEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getFixedPipelineEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (bool)((Ogre::RenderSystem const *)arg1)->getFixedPipelineEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setDepthBufferFor(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setDepthBufferFor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","setDepthBufferFor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  (arg1)->setDepthBufferFor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__useLights(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::LightList *arg2 = 0 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_useLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LightList const &","_useLights", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LightList const &","_useLights", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::LightList * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","_useLights", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  (arg1)->_useLights((Ogre::LightList const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_areFixedFunctionLightsInViewSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","areFixedFunctionLightsInViewSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (bool)((Ogre::RenderSystem const *)arg1)->areFixedFunctionLightsInViewSpace();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setWorldMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Matrix4 *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setWorldMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 &","_setWorldMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_setWorldMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->_setWorldMatrix((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setWorldMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 0 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setWorldMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","_setWorldMatrices", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","_setWorldMatrices", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  (arg1)->_setWorldMatrices((Ogre::Matrix4 const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setViewMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Matrix4 *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setViewMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 &","_setViewMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_setViewMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->_setViewMatrix((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setProjectionMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Matrix4 *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 &","_setProjectionMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_setProjectionMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->_setProjectionMatrix((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureUnitSettings(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::TextureUnitState *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureUnitSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureUnitSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TextureUnitState,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState &","_setTextureUnitSettings", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TextureUnitState &","_setTextureUnitSettings", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TextureUnitState * >(argp3);
  (arg1)->_setTextureUnitSettings(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__disableTextureUnit(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_disableTextureUnit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_disableTextureUnit", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->_disableTextureUnit(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__disableTextureUnitsFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_disableTextureUnitsFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_disableTextureUnitsFrom", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->_disableTextureUnitsFrom(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setSurfaceParams__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::ColourValue *arg5 = 0 ;
  Ogre::Real arg6 ;
  Ogre::TrackVertexColourType arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setSurfaceParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::ColourValue * >(argp5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSurfaceParams", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::TrackVertexColourType","_setSurfaceParams", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::TrackVertexColourType >(val7);
  (arg1)->_setSurfaceParams((Ogre::ColourValue const &)*arg2,(Ogre::ColourValue const &)*arg3,(Ogre::ColourValue const &)*arg4,(Ogre::ColourValue const &)*arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setSurfaceParams__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::ColourValue *arg5 = 0 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setSurfaceParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setSurfaceParams", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setSurfaceParams", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::ColourValue * >(argp5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSurfaceParams", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->_setSurfaceParams((Ogre::ColourValue const &)*arg2,(Ogre::ColourValue const &)*arg3,(Ogre::ColourValue const &)*arg4,(Ogre::ColourValue const &)*arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setSurfaceParams(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_RenderSystem__setSurfaceParams__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_RenderSystem__setSurfaceParams__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderSystem._setSurfaceParams", 
    "    void RenderSystem._setSurfaceParams(Ogre::ColourValue const &ambient, Ogre::ColourValue const &diffuse, Ogre::ColourValue const &specular, Ogre::ColourValue const &emissive, Ogre::Real shininess, Ogre::TrackVertexColourType tracking)\n"
    "    void RenderSystem._setSurfaceParams(Ogre::ColourValue const &ambient, Ogre::ColourValue const &diffuse, Ogre::ColourValue const &specular, Ogre::ColourValue const &emissive, Ogre::Real shininess)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setPointSpritesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setPointSpritesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setPointSpritesEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setPointSpritesEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setPointParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Real arg2 ;
  bool arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setPointParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_setPointParameters", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setPointParameters", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setPointParameters", 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","_setPointParameters", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setPointParameters", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","_setPointParameters", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","_setPointParameters", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  (arg1)->_setPointParameters(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTexture__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  bool arg3 ;
  Ogre::TexturePtr *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTexture", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setTexture", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__TexturePtr,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::TexturePtr const &","_setTexture", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr const &","_setTexture", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::TexturePtr * >(argp4);
  (arg1)->_setTexture(arg2,arg3,(Ogre::TexturePtr const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTexture__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  bool arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTexture", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setTexture", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setTexture", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setTexture", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->_setTexture(arg2,arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setTexture(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__TexturePtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RenderSystem__setTexture__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RenderSystem__setTexture__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._setTexture", 
    "    void RenderSystem._setTexture(size_t unit, bool enabled, Ogre::TexturePtr const &texPtr)\n"
    "    void RenderSystem._setTexture(size_t unit, bool enabled, Ogre::String const &texname)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setVertexTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::TexturePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setVertexTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setVertexTexture", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TexturePtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TexturePtr const &","_setVertexTexture", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr const &","_setVertexTexture", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TexturePtr * >(argp3);
  (arg1)->_setVertexTexture(arg2,(Ogre::TexturePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureCoordSet(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureCoordSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureCoordSet", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","_setTextureCoordSet", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->_setTextureCoordSet(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureCoordCalculation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::TexCoordCalcMethod arg3 ;
  Ogre::Frustum *arg4 = (Ogre::Frustum *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureCoordCalculation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureCoordCalculation", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TexCoordCalcMethod","_setTextureCoordCalculation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TexCoordCalcMethod >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Frustum, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Frustum const *","_setTextureCoordCalculation", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Frustum * >(argp4);
  (arg1)->_setTextureCoordCalculation(arg2,arg3,(Ogre::Frustum const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureCoordCalculation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::TexCoordCalcMethod arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureCoordCalculation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureCoordCalculation", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TexCoordCalcMethod","_setTextureCoordCalculation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TexCoordCalcMethod >(val3);
  (arg1)->_setTextureCoordCalculation(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setTextureCoordCalculation(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_Ogre__RenderSystem, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderSystem__setTextureCoordCalculation__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_RenderSystem__setTextureCoordCalculation__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._setTextureCoordCalculation", 
    "    void RenderSystem._setTextureCoordCalculation(size_t unit, Ogre::TexCoordCalcMethod m, Ogre::Frustum const *frustum)\n"
    "    void RenderSystem._setTextureCoordCalculation(size_t unit, Ogre::TexCoordCalcMethod m)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureBlendMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::LayerBlendModeEx *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureBlendMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureBlendMode", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__LayerBlendModeEx,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::LayerBlendModeEx const &","_setTextureBlendMode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LayerBlendModeEx const &","_setTextureBlendMode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::LayerBlendModeEx * >(argp3);
  (arg1)->_setTextureBlendMode(arg2,(Ogre::LayerBlendModeEx const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureUnitFiltering__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::FilterOptions arg3 ;
  Ogre::FilterOptions arg4 ;
  Ogre::FilterOptions arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureUnitFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureUnitFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FilterOptions","_setTextureUnitFiltering", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FilterOptions >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::FilterOptions","_setTextureUnitFiltering", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::FilterOptions >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::FilterOptions","_setTextureUnitFiltering", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::FilterOptions >(val5);
  (arg1)->_setTextureUnitFiltering(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureUnitFiltering__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::FilterType arg3 ;
  Ogre::FilterOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureUnitFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureUnitFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FilterType","_setTextureUnitFiltering", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FilterType >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::FilterOptions","_setTextureUnitFiltering", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::FilterOptions >(val4);
  (arg1)->_setTextureUnitFiltering(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setTextureUnitFiltering(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_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_RenderSystem__setTextureUnitFiltering__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_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_RenderSystem__setTextureUnitFiltering__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem._setTextureUnitFiltering", 
    "    void RenderSystem._setTextureUnitFiltering(size_t unit, Ogre::FilterOptions minFilter, Ogre::FilterOptions magFilter, Ogre::FilterOptions mipFilter)\n"
    "    void RenderSystem._setTextureUnitFiltering(size_t unit, Ogre::FilterType ftype, Ogre::FilterOptions filter)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureLayerAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureLayerAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureLayerAnisotropy", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(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","_setTextureLayerAnisotropy", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->_setTextureLayerAnisotropy(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureAddressingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::TextureUnitState::UVWAddressingMode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureAddressingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureAddressingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TextureUnitState__UVWAddressingMode,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::UVWAddressingMode const &","_setTextureAddressingMode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TextureUnitState::UVWAddressingMode const &","_setTextureAddressingMode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::TextureUnitState::UVWAddressingMode * >(argp3);
  (arg1)->_setTextureAddressingMode(arg2,(Ogre::TextureUnitState::UVWAddressingMode const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureBorderColour(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureBorderColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureBorderColour", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setTextureBorderColour", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setTextureBorderColour", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->_setTextureBorderColour(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureMipmapBias(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureMipmapBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureMipmapBias", 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( "", "float","_setTextureMipmapBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->_setTextureMipmapBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setTextureMatrix", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","_setTextureMatrix", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_setTextureMatrix", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  (arg1)->_setTextureMatrix(arg2,(Ogre::Matrix4 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendOperation arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendOperation","_setSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendOperation >(val4);
  (arg1)->_setSceneBlending(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  (arg1)->_setSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setSceneBlending(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_Ogre__RenderSystem, 0);
    _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_RenderSystem__setSceneBlending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RenderSystem__setSceneBlending__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._setSceneBlending", 
    "    void RenderSystem._setSceneBlending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendOperation op)\n"
    "    void RenderSystem._setSceneBlending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setSeparateSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendFactor arg4 ;
  Ogre::SceneBlendFactor arg5 ;
  Ogre::SceneBlendOperation arg6 ;
  Ogre::SceneBlendOperation arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendFactor >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::SceneBlendFactor >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::SceneBlendOperation","_setSeparateSceneBlending", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::SceneBlendOperation >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::SceneBlendOperation","_setSeparateSceneBlending", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::SceneBlendOperation >(val7);
  (arg1)->_setSeparateSceneBlending(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setSeparateSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendFactor arg4 ;
  Ogre::SceneBlendFactor arg5 ;
  Ogre::SceneBlendOperation arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendFactor >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::SceneBlendFactor >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::SceneBlendOperation","_setSeparateSceneBlending", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::SceneBlendOperation >(val6);
  (arg1)->_setSeparateSceneBlending(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setSeparateSceneBlending__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendFactor arg4 ;
  Ogre::SceneBlendFactor arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendFactor >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","_setSeparateSceneBlending", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::SceneBlendFactor >(val5);
  (arg1)->_setSeparateSceneBlending(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setSeparateSceneBlending(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _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) {
          {
            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_RenderSystem__setSeparateSceneBlending__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _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) {
          {
            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_RenderSystem__setSeparateSceneBlending__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _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) {
          {
            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) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_RenderSystem__setSeparateSceneBlending__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderSystem._setSeparateSceneBlending", 
    "    void RenderSystem._setSeparateSceneBlending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendFactor sourceFactorAlpha, Ogre::SceneBlendFactor destFactorAlpha, Ogre::SceneBlendOperation op, Ogre::SceneBlendOperation alphaOp)\n"
    "    void RenderSystem._setSeparateSceneBlending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendFactor sourceFactorAlpha, Ogre::SceneBlendFactor destFactorAlpha, Ogre::SceneBlendOperation op)\n"
    "    void RenderSystem._setSeparateSceneBlending(Ogre::SceneBlendFactor sourceFactor, Ogre::SceneBlendFactor destFactor, Ogre::SceneBlendFactor sourceFactorAlpha, Ogre::SceneBlendFactor destFactorAlpha)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setAlphaRejectSettings(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  unsigned char arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setAlphaRejectSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","_setAlphaRejectSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned char","_setAlphaRejectSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned char >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_setAlphaRejectSettings", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_setAlphaRejectSettings(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setTextureProjectionRelativeTo(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setTextureProjectionRelativeTo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setTextureProjectionRelativeTo", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(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 &","_setTextureProjectionRelativeTo", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","_setTextureProjectionRelativeTo", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->_setTextureProjectionRelativeTo(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__createDepthBufferFor(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::DepthBuffer *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_createDepthBufferFor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_createDepthBufferFor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  result = (Ogre::DepthBuffer *)(arg1)->_createDepthBufferFor(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DepthBuffer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__cleanupDepthBuffers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_cleanupDepthBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_cleanupDepthBuffers", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_cleanupDepthBuffers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__cleanupDepthBuffers__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_cleanupDepthBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_cleanupDepthBuffers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__cleanupDepthBuffers(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__cleanupDepthBuffers__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__cleanupDepthBuffers__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._cleanupDepthBuffers", 
    "    void RenderSystem._cleanupDepthBuffers(bool bCleanManualBuffers)\n"
    "    void RenderSystem._cleanupDepthBuffers()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__beginFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_beginFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_beginFrame();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__pauseFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystem::RenderSystemContext *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_pauseFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::RenderSystem::RenderSystemContext *)(arg1)->_pauseFrame();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem__RenderSystemContext, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__resumeFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderSystem::RenderSystemContext *arg2 = (Ogre::RenderSystem::RenderSystemContext *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_resumeFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystem__RenderSystemContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystem::RenderSystemContext *","_resumeFrame", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystem::RenderSystemContext * >(argp2);
  (arg1)->_resumeFrame(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__endFrame(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_endFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_endFrame();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","_setViewport", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->_setViewport(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__getViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Viewport *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_getViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::Viewport *)(arg1)->_getViewport();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CullingMode","_setCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CullingMode >(val2);
  (arg1)->_setCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__getCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CullingMode 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","_getCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::CullingMode)((Ogre::RenderSystem const *)arg1)->_getCullingMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferParams__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  bool arg3 ;
  Ogre::CompareFunction arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setDepthBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setDepthBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::CompareFunction","_setDepthBufferParams", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::CompareFunction >(val4);
  (arg1)->_setDepthBufferParams(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferParams__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setDepthBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setDepthBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_setDepthBufferParams(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferParams__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setDepthBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setDepthBufferParams(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferParams__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_setDepthBufferParams();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setDepthBufferParams(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__setDepthBufferParams__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__setDepthBufferParams__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderSystem__setDepthBufferParams__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(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_RenderSystem__setDepthBufferParams__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._setDepthBufferParams", 
    "    void RenderSystem._setDepthBufferParams(bool depthTest, bool depthWrite, Ogre::CompareFunction depthFunction)\n"
    "    void RenderSystem._setDepthBufferParams(bool depthTest, bool depthWrite)\n"
    "    void RenderSystem._setDepthBufferParams(bool depthTest)\n"
    "    void RenderSystem._setDepthBufferParams()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferCheckEnabled__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setDepthBufferCheckEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setDepthBufferCheckEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferCheckEnabled__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_setDepthBufferCheckEnabled();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setDepthBufferCheckEnabled(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__setDepthBufferCheckEnabled__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__setDepthBufferCheckEnabled__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._setDepthBufferCheckEnabled", 
    "    void RenderSystem._setDepthBufferCheckEnabled(bool enabled)\n"
    "    void RenderSystem._setDepthBufferCheckEnabled()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferWriteEnabled__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setDepthBufferWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setDepthBufferWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferWriteEnabled__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_setDepthBufferWriteEnabled();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setDepthBufferWriteEnabled(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__setDepthBufferWriteEnabled__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__setDepthBufferWriteEnabled__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._setDepthBufferWriteEnabled", 
    "    void RenderSystem._setDepthBufferWriteEnabled(bool enabled)\n"
    "    void RenderSystem._setDepthBufferWriteEnabled()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferFunction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","_setDepthBufferFunction", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (arg1)->_setDepthBufferFunction(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBufferFunction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBufferFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_setDepthBufferFunction();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setDepthBufferFunction(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__setDepthBufferFunction__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__setDepthBufferFunction__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._setDepthBufferFunction", 
    "    void RenderSystem._setDepthBufferFunction(Ogre::CompareFunction func)\n"
    "    void RenderSystem._setDepthBufferFunction()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setColourBufferWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setColourBufferWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setColourBufferWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setColourBufferWriteEnabled", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_setColourBufferWriteEnabled", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_setColourBufferWriteEnabled", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->_setColourBufferWriteEnabled(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBias__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","_setDepthBias", 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","_setDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->_setDepthBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setDepthBias__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","_setDepthBias", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->_setDepthBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setDepthBias(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__setDepthBias__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_RenderSystem__setDepthBias__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderSystem._setDepthBias", 
    "    void RenderSystem._setDepthBias(float constantBias, float slopeScaleBias)\n"
    "    void RenderSystem._setDepthBias(float constantBias)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setFog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","_setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setFog", 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","_setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setFog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","_setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setFog", 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","_setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setFog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","_setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setFog", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setFog__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","_setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","_setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","_setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->_setFog(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setFog__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::FogMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","_setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  (arg1)->_setFog(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setFog__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_setFog();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__setFog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__setFog__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__setFog__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RenderSystem__setFog__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RenderSystem__setFog__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _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_RenderSystem__setFog__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_RenderSystem__setFog__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RenderSystem._setFog", 
    "    void RenderSystem._setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void RenderSystem._setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void RenderSystem._setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void RenderSystem._setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void RenderSystem._setFog(Ogre::FogMode mode)\n"
    "    void RenderSystem._setFog()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__beginGeometryCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_beginGeometryCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_beginGeometryCount();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__getFaceCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","_getFaceCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (unsigned int)((Ogre::RenderSystem const *)arg1)->_getFaceCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__getBatchCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","_getBatchCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (unsigned int)((Ogre::RenderSystem const *)arg1)->_getBatchCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__getVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","_getVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (unsigned int)((Ogre::RenderSystem const *)arg1)->_getVertexCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_convertColourValue(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  Ogre::uint32 *arg3 = (Ogre::uint32 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","convertColourValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","convertColourValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","convertColourValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::uint32 *","convertColourValue", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::uint32 * >(argp3);
  (arg1)->convertColourValue((Ogre::ColourValue const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getColourVertexElementType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexElementType 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getColourVertexElementType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::VertexElementType)((Ogre::RenderSystem const *)arg1)->getColourVertexElementType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__convertProjectionMatrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_convertProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 &","_convertProjectionMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_convertProjectionMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_convertProjectionMatrix", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_convertProjectionMatrix", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_convertProjectionMatrix", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_convertProjectionMatrix((Ogre::Matrix4 const &)*arg2,*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__convertProjectionMatrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_convertProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 &","_convertProjectionMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","_convertProjectionMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_convertProjectionMatrix", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_convertProjectionMatrix", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  (arg1)->_convertProjectionMatrix((Ogre::Matrix4 const &)*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__convertProjectionMatrix(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RenderSystem__convertProjectionMatrix__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RenderSystem__convertProjectionMatrix__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystem._convertProjectionMatrix", 
    "    void RenderSystem._convertProjectionMatrix(Ogre::Matrix4 const &matrix, Ogre::Matrix4 &dest, bool forGpuProgram)\n"
    "    void RenderSystem._convertProjectionMatrix(Ogre::Matrix4 const &matrix, Ogre::Matrix4 &dest)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__makeProjectionMatrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Matrix4 *arg6 = 0 ;
  bool arg7 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_makeProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 const &","_makeProjectionMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","_makeProjectionMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 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","_makeProjectionMatrix", 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","_makeProjectionMatrix", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_makeProjectionMatrix", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_makeProjectionMatrix", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","_makeProjectionMatrix", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->_makeProjectionMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__makeProjectionMatrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Matrix4 *arg6 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_makeProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 const &","_makeProjectionMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","_makeProjectionMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 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","_makeProjectionMatrix", 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","_makeProjectionMatrix", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_makeProjectionMatrix", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_makeProjectionMatrix", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  (arg1)->_makeProjectionMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__makeProjectionMatrix__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Matrix4 *arg8 = 0 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_makeProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 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","_makeProjectionMatrix", 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","_makeProjectionMatrix", 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","_makeProjectionMatrix", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_makeProjectionMatrix", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_makeProjectionMatrix", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Matrix4 * >(argp8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","_makeProjectionMatrix", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  (arg1)->_makeProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7,*arg8,arg9);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__makeProjectionMatrix__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Matrix4 *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_makeProjectionMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 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","_makeProjectionMatrix", 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","_makeProjectionMatrix", 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","_makeProjectionMatrix", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","_makeProjectionMatrix", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_makeProjectionMatrix", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_makeProjectionMatrix", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Matrix4 * >(argp8);
  (arg1)->_makeProjectionMatrix(arg2,arg3,arg4,arg5,arg6,arg7,*arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__makeProjectionMatrix(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[10];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 10) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_RenderSystem__makeProjectionMatrix__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_RenderSystem__makeProjectionMatrix__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_RenderSystem__makeProjectionMatrix__SWIG_3(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_RenderSystem__makeProjectionMatrix__SWIG_2(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "RenderSystem._makeProjectionMatrix", 
    "    void RenderSystem._makeProjectionMatrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest, bool forGpuProgram)\n"
    "    void RenderSystem._makeProjectionMatrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest)\n"
    "    void RenderSystem._makeProjectionMatrix(Ogre::Real left, Ogre::Real right, Ogre::Real bottom, Ogre::Real top, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest, bool forGpuProgram)\n"
    "    void RenderSystem._makeProjectionMatrix(Ogre::Real left, Ogre::Real right, Ogre::Real bottom, Ogre::Real top, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__makeOrthoMatrix__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Matrix4 *arg6 = 0 ;
  bool arg7 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_makeOrthoMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 const &","_makeOrthoMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","_makeOrthoMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_makeOrthoMatrix", 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","_makeOrthoMatrix", 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","_makeOrthoMatrix", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_makeOrthoMatrix", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_makeOrthoMatrix", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","_makeOrthoMatrix", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->_makeOrthoMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__makeOrthoMatrix__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Matrix4 *arg6 = 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_makeOrthoMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 const &","_makeOrthoMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","_makeOrthoMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_makeOrthoMatrix", 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","_makeOrthoMatrix", 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","_makeOrthoMatrix", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 &","_makeOrthoMatrix", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_makeOrthoMatrix", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  (arg1)->_makeOrthoMatrix((Ogre::Radian const &)*arg2,arg3,arg4,arg5,*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__makeOrthoMatrix(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_RenderSystem__makeOrthoMatrix__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_RenderSystem__makeOrthoMatrix__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "RenderSystem._makeOrthoMatrix", 
    "    void RenderSystem._makeOrthoMatrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest, bool forGpuProgram)\n"
    "    void RenderSystem._makeOrthoMatrix(Ogre::Radian const &fovy, Ogre::Real aspect, Ogre::Real nearPlane, Ogre::Real farPlane, Ogre::Matrix4 &dest)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__applyObliqueDepthProjection(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  Ogre::Plane *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_applyObliqueDepthProjection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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 &","_applyObliqueDepthProjection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","_applyObliqueDepthProjection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_applyObliqueDepthProjection", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_applyObliqueDepthProjection", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_applyObliqueDepthProjection", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_applyObliqueDepthProjection(*arg2,(Ogre::Plane const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setPolygonMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::PolygonMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setPolygonMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PolygonMode","_setPolygonMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PolygonMode >(val2);
  (arg1)->_setPolygonMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilCheckEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setStencilCheckEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setStencilCheckEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  Ogre::StencilOperation arg5 ;
  Ogre::StencilOperation arg6 ;
  Ogre::StencilOperation arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::StencilOperation >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::StencilOperation >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::StencilOperation >(val7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","setStencilBufferParams", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  Ogre::StencilOperation arg5 ;
  Ogre::StencilOperation arg6 ;
  Ogre::StencilOperation arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::StencilOperation >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::StencilOperation >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::StencilOperation >(val7);
  (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  Ogre::StencilOperation arg5 ;
  Ogre::StencilOperation arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::StencilOperation >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::StencilOperation >(val6);
  (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  Ogre::StencilOperation arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilBufferParams", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::StencilOperation >(val5);
  (arg1)->setStencilBufferParams(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  (arg1)->setStencilBufferParams(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  Ogre::uint32 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilBufferParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  (arg1)->setStencilBufferParams(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilBufferParams", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (arg1)->setStencilBufferParams(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setStencilBufferParams__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setStencilBufferParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->setStencilBufferParams();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_setStencilBufferParams(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 9) 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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem_setStencilBufferParams__SWIG_7(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem_setStencilBufferParams__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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) {
          return _wrap_RenderSystem_setStencilBufferParams__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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) {
            return _wrap_RenderSystem_setStencilBufferParams__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RenderSystem_setStencilBufferParams__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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_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_RenderSystem_setStencilBufferParams__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_RenderSystem_setStencilBufferParams__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_RenderSystem_setStencilBufferParams__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "RenderSystem.setStencilBufferParams", 
    "    void RenderSystem.setStencilBufferParams(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp, Ogre::StencilOperation depthFailOp, Ogre::StencilOperation passOp, bool twoSidedOperation)\n"
    "    void RenderSystem.setStencilBufferParams(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp, Ogre::StencilOperation depthFailOp, Ogre::StencilOperation passOp)\n"
    "    void RenderSystem.setStencilBufferParams(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp, Ogre::StencilOperation depthFailOp)\n"
    "    void RenderSystem.setStencilBufferParams(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask, Ogre::StencilOperation stencilFailOp)\n"
    "    void RenderSystem.setStencilBufferParams(Ogre::CompareFunction func, Ogre::uint32 refValue, Ogre::uint32 mask)\n"
    "    void RenderSystem.setStencilBufferParams(Ogre::CompareFunction func, Ogre::uint32 refValue)\n"
    "    void RenderSystem.setStencilBufferParams(Ogre::CompareFunction func)\n"
    "    void RenderSystem.setStencilBufferParams()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","setVertexDeclaration", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  (arg1)->setVertexDeclaration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setVertexBufferBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::VertexBufferBinding *arg2 = (Ogre::VertexBufferBinding *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setVertexBufferBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","setVertexBufferBinding", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp2);
  (arg1)->setVertexBufferBinding(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setNormaliseNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setNormaliseNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setNormaliseNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setNormaliseNormals(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__render(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderOperation *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_render", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation const &","_render", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation const &","_render", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->_render((Ogre::RenderOperation const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystemCapabilities *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::RenderSystemCapabilities *)((Ogre::RenderSystem const *)arg1)->getCapabilities();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getDriverVersion(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::DriverVersion *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getDriverVersion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::DriverVersion *) &((Ogre::RenderSystem const *)arg1)->getDriverVersion();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DriverVersion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__getDefaultViewportMaterialScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","_getDefaultViewportMaterialScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::String *) &((Ogre::RenderSystem const *)arg1)->_getDefaultViewportMaterialScheme();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_bindGpuProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::GpuProgram *arg2 = (Ogre::GpuProgram *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","bindGpuProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__GpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgram *","bindGpuProgram", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgram * >(argp2);
  (arg1)->bindGpuProgram(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_bindGpuProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::GpuProgramType arg2 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg3 ;
  Ogre::uint16 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","bindGpuProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","bindGpuProgramParameters", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","bindGpuProgramParameters", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","bindGpuProgramParameters", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","bindGpuProgramParameters", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  (arg1)->bindGpuProgramParameters(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_bindGpuProgramPassIterationParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::GpuProgramType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","bindGpuProgramPassIterationParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","bindGpuProgramPassIterationParameters", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  (arg1)->bindGpuProgramPassIterationParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_unbindGpuProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::GpuProgramType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","unbindGpuProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","unbindGpuProgram", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  (arg1)->unbindGpuProgram(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_isGpuProgramBound(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::GpuProgramType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","isGpuProgramBound", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","isGpuProgramBound", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  result = (bool)(arg1)->isGpuProgramBound(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setClipPlanes(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::PlaneList *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setClipPlanes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PlaneList const &","setClipPlanes", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PlaneList const &","setClipPlanes", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PlaneList * >(argp2);
  (arg1)->setClipPlanes((Ogre::PlaneList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_addClipPlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Plane *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","addClipPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","addClipPlane", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","addClipPlane", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  (arg1)->addClipPlane((Ogre::Plane const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_addClipPlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","addClipPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addClipPlane", 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","addClipPlane", 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","addClipPlane", 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","addClipPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->addClipPlane(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_addClipPlane(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RenderSystem_addClipPlane__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RenderSystem_addClipPlane__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem.addClipPlane", 
    "    void RenderSystem.addClipPlane(Ogre::Plane const &p)\n"
    "    void RenderSystem.addClipPlane(Ogre::Real A, Ogre::Real B, Ogre::Real C, Ogre::Real D)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_resetClipPlanes(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","resetClipPlanes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->resetClipPlanes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__initRenderTargets(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_initRenderTargets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_initRenderTargets();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__notifyCameraRemoved(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_notifyCameraRemoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","_notifyCameraRemoved", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCameraRemoved((Ogre::Camera const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__updateAllRenderTargets__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_updateAllRenderTargets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_updateAllRenderTargets", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_updateAllRenderTargets(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__updateAllRenderTargets__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_updateAllRenderTargets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_updateAllRenderTargets();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__updateAllRenderTargets(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__updateAllRenderTargets__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__updateAllRenderTargets__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._updateAllRenderTargets", 
    "    void RenderSystem._updateAllRenderTargets(bool swapBuffers)\n"
    "    void RenderSystem._updateAllRenderTargets()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__swapAllRenderTargetBuffers__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_swapAllRenderTargetBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_swapAllRenderTargetBuffers", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_swapAllRenderTargetBuffers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__swapAllRenderTargetBuffers__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_swapAllRenderTargetBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->_swapAllRenderTargetBuffers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem__swapAllRenderTargetBuffers(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderSystem__swapAllRenderTargetBuffers__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem__swapAllRenderTargetBuffers__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderSystem._swapAllRenderTargetBuffers", 
    "    void RenderSystem._swapAllRenderTargetBuffers(bool waitForVsync)\n"
    "    void RenderSystem._swapAllRenderTargetBuffers()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setInvertVertexWinding(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setInvertVertexWinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInvertVertexWinding", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setInvertVertexWinding(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getInvertVertexWinding(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getInvertVertexWinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (bool)((Ogre::RenderSystem const *)arg1)->getInvertVertexWinding();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setScissorTest__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setScissorTest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setScissorTest", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setScissorTest", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setScissorTest", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","setScissorTest", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","setScissorTest", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  (arg1)->setScissorTest(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setScissorTest__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setScissorTest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setScissorTest", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setScissorTest", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setScissorTest", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","setScissorTest", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->setScissorTest(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setScissorTest__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  size_t arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setScissorTest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setScissorTest", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setScissorTest", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setScissorTest", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setScissorTest(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setScissorTest__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setScissorTest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setScissorTest", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setScissorTest", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setScissorTest(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setScissorTest__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setScissorTest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setScissorTest", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setScissorTest(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_setScissorTest(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem_setScissorTest__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RenderSystem_setScissorTest__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RenderSystem_setScissorTest__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RenderSystem_setScissorTest__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_RenderSystem_setScissorTest__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RenderSystem.setScissorTest", 
    "    void RenderSystem.setScissorTest(bool enabled, size_t left, size_t top, size_t right, size_t bottom)\n"
    "    void RenderSystem.setScissorTest(bool enabled, size_t left, size_t top, size_t right)\n"
    "    void RenderSystem.setScissorTest(bool enabled, size_t left, size_t top)\n"
    "    void RenderSystem.setScissorTest(bool enabled, size_t left)\n"
    "    void RenderSystem.setScissorTest(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_clearFrameBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  unsigned int arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  unsigned short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","clearFrameBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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","clearFrameBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","clearFrameBuffer", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","clearFrameBuffer", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","clearFrameBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned short","clearFrameBuffer", 5, argv[3] ));
  } 
  arg5 = static_cast< unsigned short >(val5);
  (arg1)->clearFrameBuffer(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_clearFrameBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  unsigned int arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","clearFrameBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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","clearFrameBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","clearFrameBuffer", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","clearFrameBuffer", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","clearFrameBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->clearFrameBuffer(arg2,(Ogre::ColourValue const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_clearFrameBuffer__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  unsigned int arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","clearFrameBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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","clearFrameBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","clearFrameBuffer", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","clearFrameBuffer", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->clearFrameBuffer(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_clearFrameBuffer__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","clearFrameBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(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","clearFrameBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->clearFrameBuffer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_clearFrameBuffer(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem_clearFrameBuffer__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RenderSystem_clearFrameBuffer__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RenderSystem_clearFrameBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_RenderSystem_clearFrameBuffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem.clearFrameBuffer", 
    "    void RenderSystem.clearFrameBuffer(unsigned int buffers, Ogre::ColourValue const &colour, Ogre::Real depth, unsigned short stencil)\n"
    "    void RenderSystem.clearFrameBuffer(unsigned int buffers, Ogre::ColourValue const &colour, Ogre::Real depth)\n"
    "    void RenderSystem.clearFrameBuffer(unsigned int buffers, Ogre::ColourValue const &colour)\n"
    "    void RenderSystem.clearFrameBuffer(unsigned int buffers)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getHorizontalTexelOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getHorizontalTexelOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::Real)(arg1)->getHorizontalTexelOffset();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getVerticalTexelOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getVerticalTexelOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::Real)(arg1)->getVerticalTexelOffset();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getMinimumDepthInputValue(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getMinimumDepthInputValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::Real)(arg1)->getMinimumDepthInputValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getMaximumDepthInputValue(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getMaximumDepthInputValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::Real)(arg1)->getMaximumDepthInputValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setCurrentPassIterationCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setCurrentPassIterationCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setCurrentPassIterationCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setCurrentPassIterationCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setDeriveDepthBias__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  float arg3 ;
  float arg4 ;
  float arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setDeriveDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDeriveDepthBias", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","setDeriveDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","setDeriveDepthBias", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "float","setDeriveDepthBias", 5, argv[3] ));
  } 
  arg5 = static_cast< float >(val5);
  (arg1)->setDeriveDepthBias(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setDeriveDepthBias__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  float arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setDeriveDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDeriveDepthBias", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","setDeriveDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","setDeriveDepthBias", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setDeriveDepthBias(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setDeriveDepthBias__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setDeriveDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDeriveDepthBias", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "float","setDeriveDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setDeriveDepthBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_setDeriveDepthBias__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setDeriveDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDeriveDepthBias", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDeriveDepthBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystem_setDeriveDepthBias(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_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderSystem_setDeriveDepthBias__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_RenderSystem_setDeriveDepthBias__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_RenderSystem_setDeriveDepthBias__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_RenderSystem_setDeriveDepthBias__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "RenderSystem.setDeriveDepthBias", 
    "    void RenderSystem.setDeriveDepthBias(bool derive, float baseValue, float multiplier, float slopeScale)\n"
    "    void RenderSystem.setDeriveDepthBias(bool derive, float baseValue, float multiplier)\n"
    "    void RenderSystem.setDeriveDepthBias(bool derive, float baseValue)\n"
    "    void RenderSystem.setDeriveDepthBias(bool derive)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem__setRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_setRenderTarget", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  (arg1)->_setRenderTarget(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderSystem::Listener *arg2 = (Ogre::RenderSystem::Listener *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystem__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystem::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystem::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  Ogre::RenderSystem::Listener *arg2 = (Ogre::RenderSystem::Listener *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystem__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystem::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystem::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getRenderSystemEvents(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getRenderSystemEvents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (Ogre::StringVector *) &((Ogre::RenderSystem const *)arg1)->getRenderSystemEvents();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_preExtraThreadsStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","preExtraThreadsStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->preExtraThreadsStarted();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_postExtraThreadsStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","postExtraThreadsStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->postExtraThreadsStarted();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_registerThread(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","registerThread", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->registerThread();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_unregisterThread(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","unregisterThread", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  (arg1)->unregisterThread();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getDisplayMonitorCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem const *","getDisplayMonitorCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (unsigned int)((Ogre::RenderSystem const *)arg1)->getDisplayMonitorCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystem_getConfigOptionHash(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystem *arg1 = (Ogre::RenderSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","getConfigOptionHash", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystem * >(argp1);
  result = (VALUE)Ogre_RenderSystem_getConfigOptionHash(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassCompositionPass;

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

SWIGINTERN VALUE
_wrap_new_CompositionPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositionPass";
  Ogre::CompositionPass *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__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","Ogre::CompositionPass", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (Ogre::CompositionPass *)new Ogre::CompositionPass(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionPass(Ogre::CompositionPass *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_CompositionPass_setType(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::CompositionPass::PassType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompositionPass::PassType","setType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompositionPass::PassType >(val2);
  (arg1)->setType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionPass::PassType 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::CompositionPass::PassType)((Ogre::CompositionPass const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setIdentifier(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setIdentifier", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setIdentifier", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setIdentifier(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getIdentifier(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getIdentifier", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getIdentifier();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::MaterialPtr *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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::CompositionPass const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setFirstRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setFirstRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setFirstRenderQueue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setFirstRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getFirstRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getFirstRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::uint8)((Ogre::CompositionPass const *)arg1)->getFirstRenderQueue();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setLastRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setLastRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setLastRenderQueue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setLastRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getLastRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getLastRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::uint8)((Ogre::CompositionPass const *)arg1)->getLastRenderQueue();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setMaterialScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setMaterialScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(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( "", "Ogre::String const &","setMaterialScheme", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialScheme", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialScheme((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getMaterialScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getMaterialScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::String *) &((Ogre::CompositionPass const *)arg1)->getMaterialScheme();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setClearBuffers(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setClearBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setClearBuffers", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setClearBuffers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getClearBuffers(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getClearBuffers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getClearBuffers();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setClearColour(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::ColourValue arg2 ;
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setClearColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue","setClearColour", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue","setClearColour", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::ColourValue * >(argp2));
    }
  }
  (arg1)->setClearColour(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getClearColour(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getClearColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::CompositionPass const *)arg1)->getClearColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setClearDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setClearDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setClearDepth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setClearDepth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getClearDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getClearDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::Real)((Ogre::CompositionPass const *)arg1)->getClearDepth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setClearStencil(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setClearStencil", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setClearStencil", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setClearStencil(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getClearStencil(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getClearStencil", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getClearStencil();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilCheck(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilCheck", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setStencilCheck", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setStencilCheck(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilCheck(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilCheck", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (bool)((Ogre::CompositionPass const *)arg1)->getStencilCheck();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilFunc(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilFunc", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setStencilFunc", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (arg1)->setStencilFunc(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilFunc(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompareFunction 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilFunc", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::CompareFunction)((Ogre::CompositionPass const *)arg1)->getStencilFunc();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilRefValue(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilRefValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilRefValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setStencilRefValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilRefValue(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilRefValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getStencilRefValue();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilMask(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setStencilMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setStencilMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilMask(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::uint32)((Ogre::CompositionPass const *)arg1)->getStencilMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilFailOp(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::StencilOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilFailOp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilFailOp", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::StencilOperation >(val2);
  (arg1)->setStencilFailOp(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilFailOp(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StencilOperation 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilFailOp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::StencilOperation)((Ogre::CompositionPass const *)arg1)->getStencilFailOp();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilDepthFailOp(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::StencilOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilDepthFailOp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilDepthFailOp", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::StencilOperation >(val2);
  (arg1)->setStencilDepthFailOp(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilDepthFailOp(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StencilOperation 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilDepthFailOp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::StencilOperation)((Ogre::CompositionPass const *)arg1)->getStencilDepthFailOp();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilPassOp(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::StencilOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilPassOp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::StencilOperation","setStencilPassOp", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::StencilOperation >(val2);
  (arg1)->setStencilPassOp(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilPassOp(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StencilOperation 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilPassOp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::StencilOperation)((Ogre::CompositionPass const *)arg1)->getStencilPassOp();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setStencilTwoSidedOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setStencilTwoSidedOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setStencilTwoSidedOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setStencilTwoSidedOperation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getStencilTwoSidedOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getStencilTwoSidedOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (bool)((Ogre::CompositionPass const *)arg1)->getStencilTwoSidedOperation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setInput__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  size_t arg2 ;
  Ogre::String *arg3 = 0 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setInput", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInput", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    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 &","setInput", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setInput", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","setInput", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->setInput(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setInput__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  size_t arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setInput", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInput", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    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 &","setInput", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setInput", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setInput(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setInput__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setInput", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInput", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setInput(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositionPass_setInput(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_Ogre__CompositionPass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CompositionPass_setInput__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositionPass, 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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_CompositionPass_setInput__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositionPass, 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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CompositionPass_setInput__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CompositionPass.setInput", 
    "    void CompositionPass.setInput(size_t id, Ogre::String const &input, size_t mrtIndex)\n"
    "    void CompositionPass.setInput(size_t id, Ogre::String const &input)\n"
    "    void CompositionPass.setInput(size_t id)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getInput(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::CompositionPass::InputTex *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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getInput", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getInput", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::CompositionPass::InputTex *) &((Ogre::CompositionPass const *)arg1)->getInput(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionPass__InputTex, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getNumInputs(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getNumInputs", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = ((Ogre::CompositionPass const *)arg1)->getNumInputs();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_clearAllInputs(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","clearAllInputs", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  (arg1)->clearAllInputs();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTargetPass *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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::CompositionTargetPass *)(arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass__isSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","_isSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (bool)(arg1)->_isSupported();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setQuadCorners(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setQuadCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setQuadCorners", 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","setQuadCorners", 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","setQuadCorners", 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","setQuadCorners", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setQuadCorners(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getQuadCorners(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::Real *arg2 = 0 ;
  Ogre::Real *arg3 = 0 ;
  Ogre::Real *arg4 = 0 ;
  Ogre::Real *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool result;
  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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getQuadCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real &","getQuadCorners", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getQuadCorners", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real &","getQuadCorners", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getQuadCorners", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real &","getQuadCorners", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getQuadCorners", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_float,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real &","getQuadCorners", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Real &","getQuadCorners", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  result = (bool)((Ogre::CompositionPass const *)arg1)->getQuadCorners(*arg2,*arg3,*arg4,*arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setQuadFarCorners(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setQuadFarCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setQuadFarCorners", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setQuadFarCorners", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setQuadFarCorners(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getQuadFarCorners(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getQuadFarCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (bool)((Ogre::CompositionPass const *)arg1)->getQuadFarCorners();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getQuadFarCornersViewSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getQuadFarCornersViewSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (bool)((Ogre::CompositionPass const *)arg1)->getQuadFarCornersViewSpace();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_setCustomType(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  Ogre::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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass *","setCustomType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(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( "", "Ogre::String const &","setCustomType", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCustomType", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setCustomType((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPass_getCustomType(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPass *arg1 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","getCustomType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPass * >(argp1);
  result = (Ogre::String *) &((Ogre::CompositionPass const *)arg1)->getCustomType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassCompositionTargetPass;

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

SWIGINTERN VALUE
_wrap_new_CompositionTargetPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositionTargetPass";
  Ogre::CompositionTargetPass *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__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","Ogre::CompositionTargetPass", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (Ogre::CompositionTargetPass *)new Ogre::CompositionTargetPass(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTargetPass(Ogre::CompositionTargetPass *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_CompositionTargetPass_setInputMode(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  Ogre::CompositionTargetPass::InputMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","setInputMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass::InputMode","setInputMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompositionTargetPass::InputMode >(val2);
  (arg1)->setInputMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getInputMode(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTargetPass::InputMode 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass const *","getInputMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (Ogre::CompositionTargetPass::InputMode)((Ogre::CompositionTargetPass const *)arg1)->getInputMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_setOutputName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  Ogre::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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","setOutputName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(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( "", "Ogre::String const &","setOutputName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setOutputName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setOutputName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getOutputName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass const *","getOutputName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (Ogre::String *) &((Ogre::CompositionTargetPass const *)arg1)->getOutputName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_setOnlyInitial(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","setOnlyInitial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setOnlyInitial", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setOnlyInitial(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getOnlyInitial(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","getOnlyInitial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (bool)(arg1)->getOnlyInitial();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_setVisibilityMask(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  Ogre::uint32 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","setVisibilityMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setVisibilityMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setVisibilityMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getVisibilityMask(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","getVisibilityMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (Ogre::uint32)(arg1)->getVisibilityMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_setMaterialScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  Ogre::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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","setMaterialScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(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( "", "Ogre::String const &","setMaterialScheme", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialScheme", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialScheme((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getMaterialScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass const *","getMaterialScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (Ogre::String *) &((Ogre::CompositionTargetPass const *)arg1)->getMaterialScheme();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_setShadowsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","setShadowsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowsEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowsEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getShadowsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass const *","getShadowsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (bool)((Ogre::CompositionTargetPass const *)arg1)->getShadowsEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_setLodBias(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","setLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setLodBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getLodBias(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","getLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (float)(arg1)->getLodBias();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_createPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionPass *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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","createPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (Ogre::CompositionPass *)(arg1)->createPass();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_removePass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","removePass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removePass", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removePass(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::CompositionPass *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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","getPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getPass", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::CompositionPass *)(arg1)->getPass(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getNumPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","getNumPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (arg1)->getNumPasses();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_removeAllPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","removeAllPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  (arg1)->removeAllPasses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getPassIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::CompositionPass *,Ogre::STLAllocator< Ogre::CompositionPass *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","getPassIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (arg1)->getPassIterator();
  vresult = SWIG_NewPointerObj((new Ogre::CompositionTargetPass::PassIterator(static_cast< const Ogre::CompositionTargetPass::PassIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTechnique *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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (Ogre::CompositionTechnique *)(arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPass__isSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPass *arg1 = (Ogre::CompositionTargetPass *) 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_Ogre__CompositionTargetPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPass *","_isSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPass * >(argp1);
  result = (bool)(arg1)->_isSupported();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassCompositionTechnique;

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

SWIGINTERN VALUE
_wrap_new_CompositionTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositionTechnique";
  Ogre::CompositionTechnique *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__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","Ogre::CompositionTechnique", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (Ogre::CompositionTechnique *)new Ogre::CompositionTechnique(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTechnique(Ogre::CompositionTechnique *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_CompositionTechnique_createTextureDefinition(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::CompositionTechnique::TextureDefinition *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","createTextureDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(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( "", "Ogre::String const &","createTextureDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createTextureDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::CompositionTechnique::TextureDefinition *)(arg1)->createTextureDefinition((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique__TextureDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_removeTextureDefinition(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","removeTextureDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removeTextureDefinition", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removeTextureDefinition(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getTextureDefinition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::CompositionTechnique::TextureDefinition *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getTextureDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getTextureDefinition", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::CompositionTechnique::TextureDefinition *)(arg1)->getTextureDefinition(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique__TextureDefinition, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getTextureDefinition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::CompositionTechnique::TextureDefinition *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getTextureDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(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( "", "Ogre::String const &","getTextureDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTextureDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::CompositionTechnique::TextureDefinition *)(arg1)->getTextureDefinition((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique__TextureDefinition, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositionTechnique_getTextureDefinition(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_Ogre__CompositionTechnique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CompositionTechnique_getTextureDefinition__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositionTechnique, 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_CompositionTechnique_getTextureDefinition__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositionTechnique.getTextureDefinition", 
    "    Ogre::CompositionTechnique::TextureDefinition * CompositionTechnique.getTextureDefinition(size_t idx)\n"
    "    Ogre::CompositionTechnique::TextureDefinition * CompositionTechnique.getTextureDefinition(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getNumTextureDefinitions(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getNumTextureDefinitions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (arg1)->getNumTextureDefinitions();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_removeAllTextureDefinitions(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","removeAllTextureDefinitions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  (arg1)->removeAllTextureDefinitions();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getTextureDefinitionIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::TextureDefinition *,Ogre::STLAllocator< Ogre::TextureDefinition *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getTextureDefinitionIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (arg1)->getTextureDefinitionIterator();
  vresult = SWIG_NewPointerObj((new Ogre::CompositionTechnique::TextureDefinitionIterator(static_cast< const Ogre::CompositionTechnique::TextureDefinitionIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_createTargetPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTargetPass *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","createTargetPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (Ogre::CompositionTargetPass *)(arg1)->createTargetPass();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_removeTargetPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","removeTargetPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removeTargetPass", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removeTargetPass(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getTargetPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::CompositionTargetPass *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getTargetPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getTargetPass", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::CompositionTargetPass *)(arg1)->getTargetPass(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getNumTargetPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getNumTargetPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (arg1)->getNumTargetPasses();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_removeAllTargetPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","removeAllTargetPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  (arg1)->removeAllTargetPasses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getTargetPassIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::CompositionTargetPass *,Ogre::STLAllocator< Ogre::CompositionTargetPass *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getTargetPassIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (arg1)->getTargetPassIterator();
  vresult = SWIG_NewPointerObj((new Ogre::CompositionTechnique::TargetPassIterator(static_cast< const Ogre::CompositionTechnique::TargetPassIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getOutputTargetPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTargetPass *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getOutputTargetPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (Ogre::CompositionTargetPass *)(arg1)->getOutputTargetPass();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTargetPass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_isSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","isSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isSupported", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)(arg1)->isSupported(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_setSchemeName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  Ogre::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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","setSchemeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(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( "", "Ogre::String const &","setSchemeName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSchemeName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSchemeName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getSchemeName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique const *","getSchemeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (Ogre::String *) &((Ogre::CompositionTechnique const *)arg1)->getSchemeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_setCompositorLogicName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  Ogre::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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","setCompositorLogicName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(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( "", "Ogre::String const &","setCompositorLogicName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCompositorLogicName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setCompositorLogicName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getCompositorLogicName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique const *","getCompositorLogicName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (Ogre::String *) &((Ogre::CompositionTechnique const *)arg1)->getCompositorLogicName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechnique_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Compositor *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_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  result = (Ogre::Compositor *)(arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Compositor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassCompositor;

SWIGINTERN VALUE
_wrap_new_Compositor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Compositor";
  Ogre::Compositor *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Compositor", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Compositor", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Compositor", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Compositor", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Compositor", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Compositor", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Compositor", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","Ogre::Compositor", 6, argv[5] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::Compositor *)new Ogre::Compositor(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Compositor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Compositor";
  Ogre::Compositor *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Compositor", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Compositor", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Compositor", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Compositor", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Compositor", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Compositor", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Compositor", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::Compositor *)new Ogre::Compositor(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Compositor__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Compositor";
  Ogre::Compositor *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Compositor", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Compositor", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Compositor", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Compositor", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Compositor", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Compositor", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::Compositor *)new Ogre::Compositor(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Compositor(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Compositor__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Compositor__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Compositor__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Compositor.new", 
    "    Compositor.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Compositor.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual)\n"
    "    Compositor.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Compositor(Ogre::Compositor *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Compositor_createTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTechnique *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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","createTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (Ogre::CompositionTechnique *)(arg1)->createTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_removeTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","removeTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removeTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removeTechnique(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::CompositionTechnique *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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::CompositionTechnique *)(arg1)->getTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getNumTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getNumTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (arg1)->getNumTechniques();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_removeAllTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","removeAllTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  (arg1)->removeAllTechniques();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getTechniqueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::CompositionTechnique *,Ogre::STLAllocator< Ogre::CompositionTechnique *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getTechniqueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (arg1)->getTechniqueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Compositor::TechniqueIterator(static_cast< const Ogre::Compositor::TechniqueIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getSupportedTechnique__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::CompositionTechnique *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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getSupportedTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getSupportedTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::CompositionTechnique *)(arg1)->getSupportedTechnique(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getNumSupportedTechniques(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getNumSupportedTechniques", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (arg1)->getNumSupportedTechniques();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getSupportedTechniqueIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::CompositionTechnique *,Ogre::STLAllocator< Ogre::CompositionTechnique *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getSupportedTechniqueIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (arg1)->getSupportedTechniqueIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Compositor::TechniqueIterator(static_cast< const Ogre::Compositor::TechniqueIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getSupportedTechnique__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::CompositionTechnique *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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getSupportedTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(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( "", "Ogre::String const &","getSupportedTechnique", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSupportedTechnique", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::CompositionTechnique *)(arg1)->getSupportedTechnique((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getSupportedTechnique__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTechnique *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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getSupportedTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (Ogre::CompositionTechnique *)(arg1)->getSupportedTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Compositor_getSupportedTechnique(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_Ogre__Compositor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Compositor_getSupportedTechnique__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Compositor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Compositor_getSupportedTechnique__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Compositor, 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_Compositor_getSupportedTechnique__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Compositor.getSupportedTechnique", 
    "    Ogre::CompositionTechnique * Compositor.getSupportedTechnique(size_t idx)\n"
    "    Ogre::CompositionTechnique * Compositor.getSupportedTechnique(Ogre::String const &schemeName)\n"
    "    Ogre::CompositionTechnique * Compositor.getSupportedTechnique()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getTextureInstanceName(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::String *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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getTextureInstanceName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(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( "", "Ogre::String const &","getTextureInstanceName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTextureInstanceName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getTextureInstanceName", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::String *) &(arg1)->getTextureInstanceName((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getTextureInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::TexturePtr 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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getTextureInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(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( "", "Ogre::String const &","getTextureInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTextureInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getTextureInstance", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->getTextureInstance((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Compositor_getRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderTarget *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_Ogre__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","getRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(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( "", "Ogre::String const &","getRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassCompositorPtr;

SWIGINTERN VALUE
_wrap_new_CompositorPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CompositorPtr";
  Ogre::CompositorPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_CompositorPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Compositor *arg1 = (Ogre::Compositor *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositorPtr";
  Ogre::CompositorPtr *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__Compositor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Compositor *","Ogre::CompositorPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Compositor * >(argp1);
  result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_CompositorPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositorPtr";
  Ogre::CompositorPtr *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__CompositorPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorPtr const &","Ogre::CompositorPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::CompositorPtr const &","Ogre::CompositorPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorPtr * >(argp1);
  result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr((Ogre::CompositorPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CompositorPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositorPtr";
  Ogre::CompositorPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::CompositorPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::CompositorPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::CompositorPtr *)new Ogre::CompositorPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_CompositorPtr(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_CompositorPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Compositor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CompositorPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CompositorPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_CompositorPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "CompositorPtr.new", 
    "    CompositorPtr.new()\n"
    "    CompositorPtr.new(Ogre::Compositor *rep)\n"
    "    CompositorPtr.new(Ogre::CompositorPtr const &r)\n"
    "    CompositorPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorPtr(Ogre::CompositorPtr *arg1) {
    delete arg1;
}

swig_class SwigClassRenderTargetEvent;

SWIGINTERN VALUE
_wrap_RenderTargetEvent_source_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetEvent *arg1 = (Ogre::RenderTargetEvent *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 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_Ogre__RenderTargetEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetEvent *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","source", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  if (arg1) (arg1)->source = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTargetEvent_source_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetEvent *arg1 = (Ogre::RenderTargetEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderTarget *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_Ogre__RenderTargetEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetEvent *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetEvent * >(argp1);
  result = (Ogre::RenderTarget *) ((arg1)->source);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderTargetEvent(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderTargetEvent";
  Ogre::RenderTargetEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderTargetEvent *)new Ogre::RenderTargetEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderTargetEvent(Ogre::RenderTargetEvent *arg1) {
    delete arg1;
}

swig_class SwigClassRenderTargetViewportEvent;

SWIGINTERN VALUE
_wrap_RenderTargetViewportEvent_source_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetViewportEvent *arg1 = (Ogre::RenderTargetViewportEvent *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__RenderTargetViewportEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","source", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  if (arg1) (arg1)->source = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTargetViewportEvent_source_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetViewportEvent *arg1 = (Ogre::RenderTargetViewportEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Viewport *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_Ogre__RenderTargetViewportEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp1);
  result = (Ogre::Viewport *) ((arg1)->source);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderTargetViewportEvent(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderTargetViewportEvent";
  Ogre::RenderTargetViewportEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderTargetViewportEvent *)new Ogre::RenderTargetViewportEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderTargetViewportEvent(Ogre::RenderTargetViewportEvent *arg1) {
    delete arg1;
}

swig_class SwigClassRenderTargetListener;

SWIGINTERN void
free_Ogre_RenderTargetListener(Ogre::RenderTargetListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderTargetListener_preRenderTargetUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetListener *arg1 = (Ogre::RenderTargetListener *) 0 ;
  Ogre::RenderTargetEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","preRenderTargetUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetEvent const &","preRenderTargetUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetEvent const &","preRenderTargetUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderTargetListener::preRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
    } else {
      (arg1)->preRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTargetListener_postRenderTargetUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetListener *arg1 = (Ogre::RenderTargetListener *) 0 ;
  Ogre::RenderTargetEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","postRenderTargetUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetEvent const &","postRenderTargetUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetEvent const &","postRenderTargetUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderTargetListener::postRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
    } else {
      (arg1)->postRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTargetListener_preViewportUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetListener *arg1 = (Ogre::RenderTargetListener *) 0 ;
  Ogre::RenderTargetViewportEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","preViewportUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent const &","preViewportUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetViewportEvent const &","preViewportUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderTargetListener::preViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
    } else {
      (arg1)->preViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTargetListener_postViewportUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetListener *arg1 = (Ogre::RenderTargetListener *) 0 ;
  Ogre::RenderTargetViewportEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","postViewportUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent const &","postViewportUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetViewportEvent const &","postViewportUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderTargetListener::postViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
    } else {
      (arg1)->postViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTargetListener_viewportAdded(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetListener *arg1 = (Ogre::RenderTargetListener *) 0 ;
  Ogre::RenderTargetViewportEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","viewportAdded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent const &","viewportAdded", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetViewportEvent const &","viewportAdded", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderTargetListener::viewportAdded((Ogre::RenderTargetViewportEvent const &)*arg2);
    } else {
      (arg1)->viewportAdded((Ogre::RenderTargetViewportEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderTargetListener_viewportRemoved(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetListener *arg1 = (Ogre::RenderTargetListener *) 0 ;
  Ogre::RenderTargetViewportEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","viewportRemoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent const &","viewportRemoved", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetViewportEvent const &","viewportRemoved", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderTargetListener::viewportRemoved((Ogre::RenderTargetViewportEvent const &)*arg2);
    } else {
      (arg1)->viewportRemoved((Ogre::RenderTargetViewportEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderTargetListener(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderTargetListener";
  Ogre::RenderTargetListener *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  arg1 = self;
  if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
    /* subclassed */
    result = (Ogre::RenderTargetListener *)new SwigDirector_RenderTargetListener(arg1); 
  } else {
    result = (Ogre::RenderTargetListener *)new Ogre::RenderTargetListener(); 
  }
  
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_disown_RenderTargetListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderTargetListener *arg1 = (Ogre::RenderTargetListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__RenderTargetListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderTargetListener *","disown_RenderTargetListener", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderTargetListener * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderQueueListener;

SWIGINTERN void
free_Ogre_RenderQueueListener(Ogre::RenderQueueListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderQueueListener_preRenderQueues(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueListener *arg1 = (Ogre::RenderQueueListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  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_Ogre__RenderQueueListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueListener *","preRenderQueues", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueListener * >(argp1);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderQueueListener::preRenderQueues();
    } else {
      (arg1)->preRenderQueues();
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueListener_postRenderQueues(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueListener *arg1 = (Ogre::RenderQueueListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  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_Ogre__RenderQueueListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueListener *","postRenderQueues", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueListener * >(argp1);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderQueueListener::postRenderQueues();
    } else {
      (arg1)->postRenderQueues();
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueListener_renderQueueStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueListener *arg1 = (Ogre::RenderQueueListener *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::String *arg3 = 0 ;
  bool *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  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_Ogre__RenderQueueListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueListener *","renderQueueStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueListener * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","renderQueueStarted", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  {
    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 &","renderQueueStarted", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","renderQueueStarted", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "bool &","renderQueueStarted", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","renderQueueStarted", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< bool * >(argp4);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderQueueListener::renderQueueStarted(arg2,(Ogre::String const &)*arg3,*arg4);
    } else {
      (arg1)->renderQueueStarted(arg2,(Ogre::String const &)*arg3,*arg4);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueListener_renderQueueEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueListener *arg1 = (Ogre::RenderQueueListener *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::String *arg3 = 0 ;
  bool *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  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_Ogre__RenderQueueListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueListener *","renderQueueEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueListener * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","renderQueueEnded", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  {
    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 &","renderQueueEnded", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","renderQueueEnded", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_bool,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "bool &","renderQueueEnded", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "bool &","renderQueueEnded", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< bool * >(argp4);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::RenderQueueListener::renderQueueEnded(arg2,(Ogre::String const &)*arg3,*arg4);
    } else {
      (arg1)->renderQueueEnded(arg2,(Ogre::String const &)*arg3,*arg4);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderQueueListener(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderQueueListener";
  Ogre::RenderQueueListener *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  arg1 = self;
  if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
    /* subclassed */
    result = (Ogre::RenderQueueListener *)new SwigDirector_RenderQueueListener(arg1); 
  } else {
    result = (Ogre::RenderQueueListener *)new Ogre::RenderQueueListener(); 
  }
  
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_disown_RenderQueueListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueListener *arg1 = (Ogre::RenderQueueListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__RenderQueueListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueListener *","disown_RenderQueueListener", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueListener * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RENDER_QUEUE_COUNT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_size_t(static_cast< size_t >(Ogre::RENDER_QUEUE_COUNT));
  return _val;
}


swig_class SwigClassCompositorInstance;

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

SWIGINTERN VALUE
_wrap_new_CompositorInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechnique *arg1 = (Ogre::CompositionTechnique *) 0 ;
  Ogre::CompositorChain *arg2 = (Ogre::CompositorChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositorInstance";
  Ogre::CompositorInstance *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__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","Ogre::CompositorInstance", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechnique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","Ogre::CompositorInstance", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorChain * >(argp2);
  result = (Ogre::CompositorInstance *)new Ogre::CompositorInstance(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorInstance(Ogre::CompositorInstance *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_CompositorInstance_setEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","setEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance const *","getEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  result = (bool)((Ogre::CompositorInstance const *)arg1)->getEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_setAlive(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","setAlive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAlive", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAlive(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getAlive(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance const *","getAlive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  result = (bool)((Ogre::CompositorInstance const *)arg1)->getAlive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getTextureInstanceName(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::String *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getTextureInstanceName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(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( "", "Ogre::String const &","getTextureInstanceName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTextureInstanceName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getTextureInstanceName", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::String *) &(arg1)->getTextureInstanceName((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getTextureInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::TexturePtr 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getTextureInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(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( "", "Ogre::String const &","getTextureInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTextureInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getTextureInstance", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->getTextureInstance((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderTarget *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(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( "", "Ogre::String const &","getRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance__compileTargetOperations(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositorInstance::CompiledState *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","_compileTargetOperations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance::CompiledState &","_compileTargetOperations", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::CompositorInstance::CompiledState &","_compileTargetOperations", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance::CompiledState * >(argp2);
  (arg1)->_compileTargetOperations(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance__compileOutputOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositorInstance::TargetOperation *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","_compileOutputOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__CompositorInstance__TargetOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance::TargetOperation &","_compileOutputOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::CompositorInstance::TargetOperation &","_compileOutputOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance::TargetOperation * >(argp2);
  (arg1)->_compileOutputOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getCompositor(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Compositor *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  result = (Ogre::Compositor *)(arg1)->getCompositor();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Compositor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositionTechnique *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  result = (Ogre::CompositionTechnique *)(arg1)->getTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_setTechnique__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositionTechnique *arg2 = (Ogre::CompositionTechnique *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","setTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","setTechnique", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositionTechnique * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setTechnique", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setTechnique(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_setTechnique__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositionTechnique *arg2 = (Ogre::CompositionTechnique *) 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","setTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositionTechnique, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique *","setTechnique", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositionTechnique * >(argp2);
  (arg1)->setTechnique(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorInstance_setTechnique(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_Ogre__CompositorInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositionTechnique, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CompositorInstance_setTechnique__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositionTechnique, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CompositorInstance_setTechnique__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorInstance.setTechnique", 
    "    void CompositorInstance.setTechnique(Ogre::CompositionTechnique *tech, bool reuseTextures)\n"
    "    void CompositorInstance.setTechnique(Ogre::CompositionTechnique *tech)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_setScheme__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","setScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(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( "", "Ogre::String const &","setScheme", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setScheme", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setScheme", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setScheme((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_setScheme__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","setScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(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( "", "Ogre::String const &","setScheme", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setScheme", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setScheme((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorInstance_setScheme(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_Ogre__CompositorInstance, 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_CompositorInstance_setScheme__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorInstance, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CompositorInstance_setScheme__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorInstance.setScheme", 
    "    void CompositorInstance.setScheme(Ogre::String const &schemeName, bool reuseTextures)\n"
    "    void CompositorInstance.setScheme(Ogre::String const &schemeName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getScheme(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance const *","getScheme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  result = (Ogre::String *) &((Ogre::CompositorInstance const *)arg1)->getScheme();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_notifyResized(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","notifyResized", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  (arg1)->notifyResized();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_getChain(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositorChain *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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  result = (Ogre::CompositorChain *)(arg1)->getChain();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositorInstance::Listener *arg2 = (Ogre::CompositorInstance::Listener *) 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositorInstance::Listener *arg2 = (Ogre::CompositorInstance::Listener *) 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance__fireNotifyMaterialSetup(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::MaterialPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","_fireNotifyMaterialSetup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","_fireNotifyMaterialSetup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MaterialPtr &","_fireNotifyMaterialSetup", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr &","_fireNotifyMaterialSetup", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::MaterialPtr * >(argp3);
  (arg1)->_fireNotifyMaterialSetup(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance__fireNotifyMaterialRender(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::MaterialPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","_fireNotifyMaterialRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","_fireNotifyMaterialRender", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MaterialPtr &","_fireNotifyMaterialRender", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr &","_fireNotifyMaterialRender", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::MaterialPtr * >(argp3);
  (arg1)->_fireNotifyMaterialRender(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorInstance__fireNotifyResourcesCreated(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorInstance *arg1 = (Ogre::CompositorInstance *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","_fireNotifyResourcesCreated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorInstance * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_fireNotifyResourcesCreated", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_fireNotifyResourcesCreated(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassCompositorChain;

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

SWIGINTERN VALUE
_wrap_new_CompositorChain(int argc, VALUE *argv, VALUE self) {
  Ogre::Viewport *arg1 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CompositorChain";
  Ogre::CompositorChain *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__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Viewport *","Ogre::CompositorChain", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Viewport * >(argp1);
  result = (Ogre::CompositorChain *)new Ogre::CompositorChain(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorChain(Ogre::CompositorChain *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_CompositorChain_addCompositor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorPtr arg2 ;
  size_t arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","addCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__CompositorPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorPtr","addCompositor", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::CompositorPtr","addCompositor", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::CompositorPtr * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","addCompositor", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","addCompositor", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addCompositor", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_addCompositor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorPtr arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","addCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__CompositorPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorPtr","addCompositor", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::CompositorPtr","addCompositor", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::CompositorPtr * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","addCompositor", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_addCompositor__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorPtr arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","addCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__CompositorPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorPtr","addCompositor", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::CompositorPtr","addCompositor", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::CompositorPtr * >(argp2));
    }
  }
  result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_addCompositor(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_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositorPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CompositorChain_addCompositor__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositorPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CompositorChain_addCompositor__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositorPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_CompositorChain_addCompositor__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CompositorChain.addCompositor", 
    "    Ogre::CompositorInstance * CompositorChain.addCompositor(Ogre::CompositorPtr filter, size_t addPosition, Ogre::String const &scheme)\n"
    "    Ogre::CompositorInstance * CompositorChain.addCompositor(Ogre::CompositorPtr filter, size_t addPosition)\n"
    "    Ogre::CompositorInstance * CompositorChain.addCompositor(Ogre::CompositorPtr filter)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_removeCompositor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","removeCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","removeCompositor", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->removeCompositor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_removeCompositor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","removeCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  (arg1)->removeCompositor();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_removeCompositor(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_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CompositorChain_removeCompositor__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CompositorChain_removeCompositor__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositorChain.removeCompositor", 
    "    void CompositorChain.removeCompositor(size_t position)\n"
    "    void CompositorChain.removeCompositor()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getNumCompositors(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getNumCompositors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  result = (arg1)->getNumCompositors();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_removeAllCompositors(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","removeAllCompositors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  (arg1)->removeAllCompositors();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getCompositor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getCompositor", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::CompositorInstance *)(arg1)->getCompositor(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getCompositor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(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( "", "Ogre::String const &","getCompositor", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getCompositor", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::CompositorInstance *)(arg1)->getCompositor((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_getCompositor(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_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CompositorChain_getCompositor__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorChain, 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_CompositorChain_getCompositor__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositorChain.getCompositor", 
    "    Ogre::CompositorInstance * CompositorChain.getCompositor(size_t index)\n"
    "    Ogre::CompositorInstance * CompositorChain.getCompositor(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain__getOriginalSceneCompositor(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","_getOriginalSceneCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  result = (Ogre::CompositorInstance *)(arg1)->_getOriginalSceneCompositor();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getCompositors(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::CompositorInstance *,Ogre::STLAllocator< Ogre::CompositorInstance *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getCompositors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  result = (arg1)->getCompositors();
  vresult = SWIG_NewPointerObj((new Ogre::CompositorChain::InstanceIterator(static_cast< const Ogre::CompositorChain::InstanceIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_setCompositorEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  size_t arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","setCompositorEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setCompositorEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setCompositorEnabled", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setCompositorEnabled(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_preRenderTargetUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::RenderTargetEvent *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","preRenderTargetUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetEvent const &","preRenderTargetUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetEvent const &","preRenderTargetUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetEvent * >(argp2);
  (arg1)->preRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_postRenderTargetUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::RenderTargetEvent *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","postRenderTargetUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetEvent const &","postRenderTargetUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetEvent const &","postRenderTargetUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetEvent * >(argp2);
  (arg1)->postRenderTargetUpdate((Ogre::RenderTargetEvent const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_preViewportUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::RenderTargetViewportEvent *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","preViewportUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent const &","preViewportUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetViewportEvent const &","preViewportUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp2);
  (arg1)->preViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_postViewportUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::RenderTargetViewportEvent *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","postViewportUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderTargetViewportEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTargetViewportEvent const &","postViewportUpdate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderTargetViewportEvent const &","postViewportUpdate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTargetViewportEvent * >(argp2);
  (arg1)->postViewportUpdate((Ogre::RenderTargetViewportEvent const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_viewportCameraChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","viewportCameraChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","viewportCameraChanged", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->viewportCameraChanged(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_viewportDimensionsChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","viewportDimensionsChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","viewportDimensionsChanged", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->viewportDimensionsChanged(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_viewportDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","viewportDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","viewportDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->viewportDestroyed(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain__markDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","_markDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  (arg1)->_markDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Viewport *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  result = (Ogre::Viewport *)(arg1)->getViewport();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain__removeInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","_removeInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","_removeInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  (arg1)->_removeInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain__queuedOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorInstance::RenderSystemOperation *arg2 = (Ogre::CompositorInstance::RenderSystemOperation *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","_queuedOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance__RenderSystemOperation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance::RenderSystemOperation *","_queuedOperation", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance::RenderSystemOperation * >(argp2);
  (arg1)->_queuedOperation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain__compile(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","_compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  (arg1)->_compile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getPreviousInstance__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getPreviousInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getPreviousInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","getPreviousInstance", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::CompositorInstance *)(arg1)->getPreviousInstance(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getPreviousInstance__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getPreviousInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getPreviousInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  result = (Ogre::CompositorInstance *)(arg1)->getPreviousInstance(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_getPreviousInstance(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_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositorInstance, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CompositorChain_getPreviousInstance__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositorInstance, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CompositorChain_getPreviousInstance__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorChain.getPreviousInstance", 
    "    Ogre::CompositorInstance * CompositorChain.getPreviousInstance(Ogre::CompositorInstance *curr, bool activeOnly)\n"
    "    Ogre::CompositorInstance * CompositorChain.getPreviousInstance(Ogre::CompositorInstance *curr)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getNextInstance__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getNextInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getNextInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","getNextInstance", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::CompositorInstance *)(arg1)->getNextInstance(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorChain_getNextInstance__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorChain *arg1 = (Ogre::CompositorChain *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","getNextInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorChain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getNextInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  result = (Ogre::CompositorInstance *)(arg1)->getNextInstance(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorChain_getNextInstance(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_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositorInstance, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_CompositorChain_getNextInstance__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorChain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__CompositorInstance, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_CompositorChain_getNextInstance__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "CompositorChain.getNextInstance", 
    "    Ogre::CompositorInstance * CompositorChain.getNextInstance(Ogre::CompositorInstance *curr, bool activeOnly)\n"
    "    Ogre::CompositorInstance * CompositorChain.getNextInstance(Ogre::CompositorInstance *curr)\n");
  
  return Qnil;
}


swig_class SwigClassCompositorLogic;

SWIGINTERN VALUE
_wrap_CompositorLogic_compositorInstanceCreated(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorLogic *arg1 = (Ogre::CompositorLogic *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 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_Ogre__CompositorLogic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorLogic *","compositorInstanceCreated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorLogic * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","compositorInstanceCreated", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  (arg1)->compositorInstanceCreated(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorLogic_compositorInstanceDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorLogic *arg1 = (Ogre::CompositorLogic *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 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_Ogre__CompositorLogic, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorLogic *","compositorInstanceDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorLogic * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","compositorInstanceDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  (arg1)->compositorInstanceDestroyed(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorLogic(Ogre::CompositorLogic *arg1) {
    delete arg1;
}

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

SWIGINTERN VALUE
_wrap_new_CompositorLogic(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CompositorLogic";
  Ogre::CompositorLogic *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositorLogic *)new Ogre::CompositorLogic();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


swig_class SwigClassRectangle2D;

SWIGINTERN VALUE
_wrap_new_Rectangle2D__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  Ogre::HardwareBuffer::Usage arg2 ;
  bool val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Rectangle2D";
  Ogre::Rectangle2D *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::Rectangle2D", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","Ogre::Rectangle2D", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::Usage >(val2);
  result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Rectangle2D__SWIG_1(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Rectangle2D";
  Ogre::Rectangle2D *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::Rectangle2D", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Rectangle2D__SWIG_2(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Rectangle2D";
  Ogre::Rectangle2D *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Rectangle2D__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  Ogre::HardwareBuffer::Usage arg3 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Rectangle2D";
  Ogre::Rectangle2D *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Rectangle2D", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Rectangle2D", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Rectangle2D", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","Ogre::Rectangle2D", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::HardwareBuffer::Usage >(val3);
  result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Rectangle2D__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  bool arg2 ;
  int res1 = SWIG_OLDOBJ ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Rectangle2D";
  Ogre::Rectangle2D *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::Rectangle2D", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Rectangle2D", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::Rectangle2D", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Rectangle2D__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Rectangle2D";
  Ogre::Rectangle2D *result = 0 ;
  
  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 &","Ogre::Rectangle2D", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Rectangle2D", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Rectangle2D *)new Ogre::Rectangle2D((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Rectangle2D(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_Rectangle2D__SWIG_2(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_new_Rectangle2D__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_Rectangle2D__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Rectangle2D__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_bool(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_Rectangle2D__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Rectangle2D__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Rectangle2D.new", 
    "    Rectangle2D.new(bool includeTextureCoordinates, Ogre::HardwareBuffer::Usage vBufUsage)\n"
    "    Rectangle2D.new(bool includeTextureCoordinates)\n"
    "    Rectangle2D.new()\n"
    "    Rectangle2D.new(Ogre::String const &name, bool includeTextureCoordinates, Ogre::HardwareBuffer::Usage vBufUsage)\n"
    "    Rectangle2D.new(Ogre::String const &name, bool includeTextureCoordinates)\n"
    "    Rectangle2D.new(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Rectangle2D(Ogre::Rectangle2D *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Rectangle2D_setCorners__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle2D *arg1 = (Ogre::Rectangle2D *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Rectangle2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle2D *","setCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle2D * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setCorners", 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","setCorners", 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","setCorners", 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","setCorners", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","setCorners", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->setCorners(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle2D_setCorners__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle2D *arg1 = (Ogre::Rectangle2D *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Rectangle2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle2D *","setCorners", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle2D * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setCorners", 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","setCorners", 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","setCorners", 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","setCorners", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setCorners(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Rectangle2D_setCorners(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Rectangle2D, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Rectangle2D_setCorners__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Rectangle2D, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Rectangle2D_setCorners__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Rectangle2D.setCorners", 
    "    void Rectangle2D.setCorners(Ogre::Real left, Ogre::Real top, Ogre::Real right, Ogre::Real bottom, bool updateAABB)\n"
    "    void Rectangle2D.setCorners(Ogre::Real left, Ogre::Real top, Ogre::Real right, Ogre::Real bottom)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle2D_setNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle2D *arg1 = (Ogre::Rectangle2D *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__Rectangle2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle2D *","setNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle2D * >(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 &","setNormals", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setNormals", 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 &","setNormals", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setNormals", 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 &","setNormals", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setNormals", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setNormals", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setNormals", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->setNormals((Ogre::Vector3 const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle2D_setUVs(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle2D *arg1 = (Ogre::Rectangle2D *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Ogre::Vector2 *arg3 = 0 ;
  Ogre::Vector2 *arg4 = 0 ;
  Ogre::Vector2 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__Rectangle2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle2D *","setUVs", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle2D * >(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 &","setUVs", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setUVs", 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 &","setUVs", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setUVs", 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 &","setUVs", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setUVs", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector2 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector2,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector2 const &","setUVs", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","setUVs", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector2 * >(argp5);
  (arg1)->setUVs((Ogre::Vector2 const &)*arg2,(Ogre::Vector2 const &)*arg3,(Ogre::Vector2 const &)*arg4,(Ogre::Vector2 const &)*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle2D_setDefaultUVs(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle2D *arg1 = (Ogre::Rectangle2D *) 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_Ogre__Rectangle2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle2D *","setDefaultUVs", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle2D * >(argp1);
  (arg1)->setDefaultUVs();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle2D_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle2D *arg1 = (Ogre::Rectangle2D *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__Rectangle2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle2D const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle2D * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::Rectangle2D const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Rectangle2D_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Rectangle2D *arg1 = (Ogre::Rectangle2D *) 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_Ogre__Rectangle2D, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Rectangle2D const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Rectangle2D * >(argp1);
  result = (Ogre::Real)((Ogre::Rectangle2D const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassCompositorManager;

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

SWIGINTERN VALUE
_wrap_new_CompositorManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CompositorManager";
  Ogre::CompositorManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositorManager *)new Ogre::CompositorManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorManager(Ogre::CompositorManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_CompositorManager_createImpl(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg7 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Ogre::Resource *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","createImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(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( "", "Ogre::String const &","createImpl", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createImpl", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","createImpl", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createImpl", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createImpl", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createImpl", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createImpl", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,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, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createImpl", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< Ogre::NameValuePairList * >(argp7);
  result = (Ogre::Resource *)(arg1)->createImpl((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_getCompositorChain(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::CompositorChain *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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","getCompositorChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","getCompositorChain", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  result = (Ogre::CompositorChain *)(arg1)->getCompositorChain(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_hasCompositorChain(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager const *","hasCompositorChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","hasCompositorChain", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  result = (bool)((Ogre::CompositorManager const *)arg1)->hasCompositorChain(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_removeCompositorChain(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","removeCompositorChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","removeCompositorChain", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  (arg1)->removeCompositorChain(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_addCompositor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  Ogre::String *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::CompositorInstance *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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","addCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","addCompositor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  {
    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 &","addCompositor", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addCompositor", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","addCompositor", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_addCompositor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::CompositorInstance *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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","addCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","addCompositor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  {
    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 &","addCompositor", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addCompositor", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::CompositorInstance *)(arg1)->addCompositor(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorManager_addCompositor(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_Ogre__CompositorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Viewport, 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_CompositorManager_addCompositor__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_CompositorManager_addCompositor__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "CompositorManager.addCompositor", 
    "    Ogre::CompositorInstance * CompositorManager.addCompositor(Ogre::Viewport *vp, Ogre::String const &compositor, int addPosition)\n"
    "    Ogre::CompositorInstance * CompositorManager.addCompositor(Ogre::Viewport *vp, Ogre::String const &compositor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_removeCompositor(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","removeCompositor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","removeCompositor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  {
    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 &","removeCompositor", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeCompositor", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->removeCompositor(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_setCompositorEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::Viewport *arg2 = (Ogre::Viewport *) 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","setCompositorEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Viewport *","setCompositorEnabled", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Viewport * >(argp2);
  {
    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 &","setCompositorEnabled", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCompositorEnabled", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","setCompositorEnabled", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->setCompositorEnabled(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager__getTexturedRectangle2D(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Renderable *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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","_getTexturedRectangle2D", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  result = (Ogre::Renderable *)(arg1)->_getTexturedRectangle2D();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_removeAll(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","removeAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  (arg1)->removeAll();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager__reconstructAllCompositorResources(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","_reconstructAllCompositorResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  (arg1)->_reconstructAllCompositorResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_getPooledTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PixelFormat arg6 ;
  Ogre::uint arg7 ;
  Ogre::String *arg8 = 0 ;
  bool arg9 ;
  Ogre::CompositorManager::UniqueTextureSet *arg10 = 0 ;
  Ogre::CompositorInstance *arg11 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositionTechnique::TextureScope arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  unsigned int val7 ;
  int ecode7 = 0 ;
  int res8 = SWIG_OLDOBJ ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  void *argp11 = 0 ;
  int res11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  Ogre::TexturePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","getPooledTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(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( "", "Ogre::String const &","getPooledTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getPooledTexture", 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 &","getPooledTexture", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getPooledTexture", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","getPooledTexture", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","getPooledTexture", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PixelFormat","getPooledTexture", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PixelFormat >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint","getPooledTexture", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint >(val7);
  {
    std::string *ptr = (std::string *)0;
    res8 = SWIG_AsPtr_std_string(argv[6], &ptr);
    if (!SWIG_IsOK(res8)) {
      SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::String const &","getPooledTexture", 8, argv[6] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getPooledTexture", 8, argv[6])); 
    }
    arg8 = ptr;
  }
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","getPooledTexture", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(argv[8], &argp10, SWIGTYPE_p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "Ogre::CompositorManager::UniqueTextureSet &","getPooledTexture", 10, argv[8] )); 
  }
  if (!argp10) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::CompositorManager::UniqueTextureSet &","getPooledTexture", 10, argv[8])); 
  }
  arg10 = reinterpret_cast< Ogre::CompositorManager::UniqueTextureSet * >(argp10);
  res11 = SWIG_ConvertPtr(argv[9], &argp11,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res11)) {
    SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","getPooledTexture", 11, argv[9] )); 
  }
  arg11 = reinterpret_cast< Ogre::CompositorInstance * >(argp11);
  ecode12 = SWIG_AsVal_int(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::CompositionTechnique::TextureScope","getPooledTexture", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::CompositionTechnique::TextureScope >(val12);
  result = (arg1)->getPooledTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::String const &)*arg8,arg9,*arg10,arg11,arg12);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res8)) delete arg8;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_freePooledTextures__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","freePooledTextures", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","freePooledTextures", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->freePooledTextures(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_freePooledTextures__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","freePooledTextures", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(argp1);
  (arg1)->freePooledTextures();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_CompositorManager_freePooledTextures(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_Ogre__CompositorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_CompositorManager_freePooledTextures__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__CompositorManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_CompositorManager_freePooledTextures__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "CompositorManager.freePooledTextures", 
    "    void CompositorManager.freePooledTextures(bool onlyIfUnreferenced)\n"
    "    void CompositorManager.freePooledTextures()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_registerCompositorLogic(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::CompositorLogic *arg3 = (Ogre::CompositorLogic *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","registerCompositorLogic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(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( "", "Ogre::String const &","registerCompositorLogic", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","registerCompositorLogic", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__CompositorLogic, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::CompositorLogic *","registerCompositorLogic", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::CompositorLogic * >(argp3);
  (arg1)->registerCompositorLogic((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_unregisterCompositorLogic(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","unregisterCompositorLogic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(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( "", "Ogre::String const &","unregisterCompositorLogic", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unregisterCompositorLogic", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unregisterCompositorLogic((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_getCompositorLogic(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::CompositorLogic *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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","getCompositorLogic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(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( "", "Ogre::String const &","getCompositorLogic", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getCompositorLogic", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::CompositorLogic *)(arg1)->getCompositorLogic((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorLogic, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_registerCustomCompositionPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::CustomCompositionPass *arg3 = (Ogre::CustomCompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","registerCustomCompositionPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(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( "", "Ogre::String const &","registerCustomCompositionPass", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","registerCustomCompositionPass", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__CustomCompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::CustomCompositionPass *","registerCustomCompositionPass", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::CustomCompositionPass * >(argp3);
  (arg1)->registerCustomCompositionPass((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_getCustomCompositionPass(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *arg1 = (Ogre::CompositorManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::CustomCompositionPass *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_Ogre__CompositorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorManager *","getCustomCompositionPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorManager * >(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( "", "Ogre::String const &","getCustomCompositionPass", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getCustomCompositionPass", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::CustomCompositionPass *)(arg1)->getCustomCompositionPass((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CustomCompositionPass, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositorManager *) &Ogre::CompositorManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositorManager *)Ogre::CompositorManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassConfigFile;

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

SWIGINTERN VALUE
_wrap_new_ConfigFile(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ConfigFile";
  Ogre::ConfigFile *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ConfigFile *)new Ogre::ConfigFile();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ConfigFile(Ogre::ConfigFile *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ConfigFile_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","load", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->load((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","load", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_load__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_load__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","load", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->load((Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_load__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->load((Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_load__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->load((Ogre::DataStreamPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConfigFile_load(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_Ogre__ConfigFile, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConfigFile_load__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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_ConfigFile_load__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_ConfigFile_load__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ConfigFile_load__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConfigFile_load__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ConfigFile_load__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ConfigFile_load__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ConfigFile.load", 
    "    void ConfigFile.load(Ogre::String const &filename, Ogre::String const &separators, bool trimWhitespace)\n"
    "    void ConfigFile.load(Ogre::String const &filename)\n"
    "    void ConfigFile.load(Ogre::String const &filename, Ogre::String const &resourceGroup, Ogre::String const &separators, bool trimWhitespace)\n"
    "    void ConfigFile.load(Ogre::String const &filename, Ogre::String const &resourceGroup, Ogre::String const &separators)\n"
    "    void ConfigFile.load(Ogre::DataStreamPtr const &stream, Ogre::String const &separators, bool trimWhitespace)\n"
    "    void ConfigFile.load(Ogre::DataStreamPtr const &stream, Ogre::String const &separators)\n"
    "    void ConfigFile.load(Ogre::DataStreamPtr const &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_loadDirect__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","loadDirect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","loadDirect", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadDirect", 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 &","loadDirect", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadDirect", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","loadDirect", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->loadDirect((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_loadDirect__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","loadDirect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","loadDirect", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadDirect", 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 &","loadDirect", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadDirect", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->loadDirect((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_loadDirect__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","loadDirect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","loadDirect", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadDirect", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->loadDirect((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConfigFile_loadDirect(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_Ogre__ConfigFile, 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_ConfigFile_loadDirect__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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_ConfigFile_loadDirect__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ConfigFile_loadDirect__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ConfigFile.loadDirect", 
    "    void ConfigFile.loadDirect(Ogre::String const &filename, Ogre::String const &separators, bool trimWhitespace)\n"
    "    void ConfigFile.loadDirect(Ogre::String const &filename, Ogre::String const &separators)\n"
    "    void ConfigFile.loadDirect(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_loadFromResourceSystem__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","loadFromResourceSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","loadFromResourceSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 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 &","loadFromResourceSystem", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","loadFromResourceSystem", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","loadFromResourceSystem", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->loadFromResourceSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_loadFromResourceSystem__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","loadFromResourceSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","loadFromResourceSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 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 &","loadFromResourceSystem", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","loadFromResourceSystem", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->loadFromResourceSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_loadFromResourceSystem__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","loadFromResourceSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","loadFromResourceSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 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 &","loadFromResourceSystem", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromResourceSystem", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->loadFromResourceSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConfigFile_loadFromResourceSystem(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_Ogre__ConfigFile, 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_ConfigFile_loadFromResourceSystem__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConfigFile_loadFromResourceSystem__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ConfigFile_loadFromResourceSystem__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ConfigFile.loadFromResourceSystem", 
    "    void ConfigFile.loadFromResourceSystem(Ogre::String const &filename, Ogre::String const &resourceGroup, Ogre::String const &separators, bool trimWhitespace)\n"
    "    void ConfigFile.loadFromResourceSystem(Ogre::String const &filename, Ogre::String const &resourceGroup, Ogre::String const &separators)\n"
    "    void ConfigFile.loadFromResourceSystem(Ogre::String const &filename, Ogre::String const &resourceGroup)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_getSetting__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile const *","getSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","getSetting", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSetting", 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 &","getSetting", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSetting", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","getSetting", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSetting", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = ((Ogre::ConfigFile const *)arg1)->getSetting((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_getSetting__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile const *","getSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","getSetting", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSetting", 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 &","getSetting", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSetting", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = ((Ogre::ConfigFile const *)arg1)->getSetting((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  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_ConfigFile_getSetting__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::String 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile const *","getSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","getSetting", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSetting", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::ConfigFile const *)arg1)->getSetting((Ogre::String const &)*arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConfigFile_getSetting(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_Ogre__ConfigFile, 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_ConfigFile_getSetting__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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_ConfigFile_getSetting__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ConfigFile_getSetting__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ConfigFile.getSetting", 
    "    Ogre::String ConfigFile.getSetting(Ogre::String const &key, Ogre::String const &section, Ogre::String const &defaultValue)\n"
    "    Ogre::String ConfigFile.getSetting(Ogre::String const &key, Ogre::String const &section)\n"
    "    Ogre::String ConfigFile.getSetting(Ogre::String const &key)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_getMultiSetting__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile const *","getMultiSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","getMultiSetting", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMultiSetting", 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 &","getMultiSetting", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMultiSetting", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = ((Ogre::ConfigFile const *)arg1)->getMultiSetting((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVector(static_cast< const Ogre::StringVector& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 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_ConfigFile_getMultiSetting__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile const *","getMultiSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","getMultiSetting", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMultiSetting", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::ConfigFile const *)arg1)->getMultiSetting((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVector(static_cast< const Ogre::StringVector& >(result))), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConfigFile_getMultiSetting(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_Ogre__ConfigFile, 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_ConfigFile_getMultiSetting__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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_ConfigFile_getMultiSetting__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ConfigFile.getMultiSetting", 
    "    Ogre::StringVector ConfigFile.getMultiSetting(Ogre::String const &key, Ogre::String const &section)\n"
    "    Ogre::StringVector ConfigFile.getMultiSetting(Ogre::String const &key)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_getSectionIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ConfigFile::SettingsMultiMap *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ConfigFile::SettingsMultiMap * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","getSectionIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(argp1);
  result = (arg1)->getSectionIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ConfigFile::SectionIterator(static_cast< const Ogre::ConfigFile::SectionIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_getSettingsIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::multimap< Ogre::String,Ogre::String,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::String >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","getSettingsIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(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( "", "Ogre::String const &","getSettingsIterator", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSettingsIterator", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getSettingsIterator((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ConfigFile::SettingsIterator(static_cast< const Ogre::ConfigFile::SettingsIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_getSettingsIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::multimap< Ogre::String,Ogre::String,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::String >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","getSettingsIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(argp1);
  result = (arg1)->getSettingsIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ConfigFile::SettingsIterator(static_cast< const Ogre::ConfigFile::SettingsIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConfigFile_getSettingsIterator(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_Ogre__ConfigFile, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ConfigFile_getSettingsIterator__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConfigFile, 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_ConfigFile_getSettingsIterator__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ConfigFile.getSettingsIterator", 
    "    Ogre::ConfigFile::SettingsIterator ConfigFile.getSettingsIterator(Ogre::String const &section)\n"
    "    Ogre::ConfigFile::SettingsIterator ConfigFile.getSettingsIterator()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ConfigFile.clear

  call-seq:
    clear

Clear ConfigFile contents.
*/
SWIGINTERN VALUE
_wrap_ConfigFile_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConfigFile_each_Settings(int argc, VALUE *argv, VALUE self) {
  Ogre::ConfigFile *arg1 = (Ogre::ConfigFile *) 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_Ogre__ConfigFile, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConfigFile *","each_Settings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConfigFile * >(argp1);
  Ogre_ConfigFile_each_Settings(arg1);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassFrameTimeControllerValue;

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

SWIGINTERN VALUE
_wrap_new_FrameTimeControllerValue(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::FrameTimeControllerValue";
  Ogre::FrameTimeControllerValue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FrameTimeControllerValue *)new Ogre::FrameTimeControllerValue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_frameEnded(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 0 ;
  Ogre::FrameEvent *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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue *","frameEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent const &","frameEnded", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent const &","frameEnded", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  result = (bool)(arg1)->frameEnded((Ogre::FrameEvent const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_frameStarted(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 0 ;
  Ogre::FrameEvent *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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue *","frameStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent const &","frameStarted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent const &","frameStarted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  result = (bool)(arg1)->frameStarted((Ogre::FrameEvent const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_setValue(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_getTimeFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue const *","getTimeFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getTimeFactor();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_setTimeFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue *","setTimeFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTimeFactor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTimeFactor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_getFrameDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue const *","getFrameDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getFrameDelay();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_setFrameDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue *","setFrameDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFrameDelay", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setFrameDelay(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_getElapsedTime(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue const *","getElapsedTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::FrameTimeControllerValue const *)arg1)->getElapsedTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FrameTimeControllerValue_setElapsedTime(int argc, VALUE *argv, VALUE self) {
  Ogre::FrameTimeControllerValue *arg1 = (Ogre::FrameTimeControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__FrameTimeControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FrameTimeControllerValue *","setElapsedTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FrameTimeControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setElapsedTime", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setElapsedTime(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FrameTimeControllerValue(Ogre::FrameTimeControllerValue *arg1) {
    delete arg1;
}

swig_class SwigClassTextureFrameControllerValue;

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

SWIGINTERN VALUE
_wrap_new_TextureFrameControllerValue(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TextureFrameControllerValue";
  Ogre::TextureFrameControllerValue *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__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","Ogre::TextureFrameControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TextureFrameControllerValue *)new Ogre::TextureFrameControllerValue(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureFrameControllerValue_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureFrameControllerValue *arg1 = (Ogre::TextureFrameControllerValue *) 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_Ogre__TextureFrameControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureFrameControllerValue const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureFrameControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::TextureFrameControllerValue const *)arg1)->getValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureFrameControllerValue_setValue(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureFrameControllerValue *arg1 = (Ogre::TextureFrameControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextureFrameControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureFrameControllerValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureFrameControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextureFrameControllerValue(Ogre::TextureFrameControllerValue *arg1) {
    delete arg1;
}

swig_class SwigClassTexCoordModifierControllerValue;

SWIGINTERN VALUE
_wrap_new_TexCoordModifierControllerValue__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexCoordModifierControllerValue";
  Ogre::TexCoordModifierControllerValue *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","Ogre::TexCoordModifierControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3,arg4,arg5,arg6);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TexCoordModifierControllerValue__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexCoordModifierControllerValue";
  Ogre::TexCoordModifierControllerValue *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","Ogre::TexCoordModifierControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TexCoordModifierControllerValue__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexCoordModifierControllerValue";
  Ogre::TexCoordModifierControllerValue *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","Ogre::TexCoordModifierControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TexCoordModifierControllerValue__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexCoordModifierControllerValue";
  Ogre::TexCoordModifierControllerValue *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","Ogre::TexCoordModifierControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TexCoordModifierControllerValue__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexCoordModifierControllerValue";
  Ogre::TexCoordModifierControllerValue *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__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","Ogre::TexCoordModifierControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::TexCoordModifierControllerValue", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TexCoordModifierControllerValue__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitState *arg1 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TexCoordModifierControllerValue";
  Ogre::TexCoordModifierControllerValue *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__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","Ogre::TexCoordModifierControllerValue", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitState * >(argp1);
  result = (Ogre::TexCoordModifierControllerValue *)new Ogre::TexCoordModifierControllerValue(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TexCoordModifierControllerValue(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TexCoordModifierControllerValue__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TexCoordModifierControllerValue__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_TexCoordModifierControllerValue__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_TexCoordModifierControllerValue__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_TexCoordModifierControllerValue__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_TexCoordModifierControllerValue__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TexCoordModifierControllerValue.new", 
    "    TexCoordModifierControllerValue.new(Ogre::TextureUnitState *t, bool translateU, bool translateV, bool scaleU, bool scaleV, bool rotate)\n"
    "    TexCoordModifierControllerValue.new(Ogre::TextureUnitState *t, bool translateU, bool translateV, bool scaleU, bool scaleV)\n"
    "    TexCoordModifierControllerValue.new(Ogre::TextureUnitState *t, bool translateU, bool translateV, bool scaleU)\n"
    "    TexCoordModifierControllerValue.new(Ogre::TextureUnitState *t, bool translateU, bool translateV)\n"
    "    TexCoordModifierControllerValue.new(Ogre::TextureUnitState *t, bool translateU)\n"
    "    TexCoordModifierControllerValue.new(Ogre::TextureUnitState *t)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TexCoordModifierControllerValue_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::TexCoordModifierControllerValue *arg1 = (Ogre::TexCoordModifierControllerValue *) 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_Ogre__TexCoordModifierControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TexCoordModifierControllerValue const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TexCoordModifierControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::TexCoordModifierControllerValue const *)arg1)->getValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TexCoordModifierControllerValue_setValue(int argc, VALUE *argv, VALUE self) {
  Ogre::TexCoordModifierControllerValue *arg1 = (Ogre::TexCoordModifierControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TexCoordModifierControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TexCoordModifierControllerValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TexCoordModifierControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TexCoordModifierControllerValue(Ogre::TexCoordModifierControllerValue *arg1) {
    delete arg1;
}

swig_class SwigClassFloatGpuParameterControllerValue;

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

SWIGINTERN VALUE
_wrap_new_FloatGpuParameterControllerValue(int argc, VALUE *argv, VALUE self) {
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg1 ;
  size_t arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FloatGpuParameterControllerValue";
  Ogre::FloatGpuParameterControllerValue *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__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res1)) {
      SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","Ogre::FloatGpuParameterControllerValue", 1, argv[0] )); 
    }  
    if (!argp1) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","Ogre::FloatGpuParameterControllerValue", 1, argv[0]));
    } else {
      arg1 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp1));
    }
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::FloatGpuParameterControllerValue", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::FloatGpuParameterControllerValue *)new Ogre::FloatGpuParameterControllerValue(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FloatGpuParameterControllerValue(Ogre::FloatGpuParameterControllerValue *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FloatGpuParameterControllerValue_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::FloatGpuParameterControllerValue *arg1 = (Ogre::FloatGpuParameterControllerValue *) 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_Ogre__FloatGpuParameterControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FloatGpuParameterControllerValue const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FloatGpuParameterControllerValue * >(argp1);
  result = (Ogre::Real)((Ogre::FloatGpuParameterControllerValue const *)arg1)->getValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FloatGpuParameterControllerValue_setValue(int argc, VALUE *argv, VALUE self) {
  Ogre::FloatGpuParameterControllerValue *arg1 = (Ogre::FloatGpuParameterControllerValue *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__FloatGpuParameterControllerValue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FloatGpuParameterControllerValue *","setValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FloatGpuParameterControllerValue * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPassthroughControllerFunction;

SWIGINTERN VALUE
_wrap_new_PassthroughControllerFunction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PassthroughControllerFunction";
  Ogre::PassthroughControllerFunction *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::PassthroughControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  result = (Ogre::PassthroughControllerFunction *)new Ogre::PassthroughControllerFunction(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PassthroughControllerFunction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PassthroughControllerFunction";
  Ogre::PassthroughControllerFunction *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PassthroughControllerFunction *)new Ogre::PassthroughControllerFunction();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PassthroughControllerFunction(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_PassthroughControllerFunction__SWIG_1(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_bool(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_PassthroughControllerFunction__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PassthroughControllerFunction.new", 
    "    PassthroughControllerFunction.new(bool deltaInput)\n"
    "    PassthroughControllerFunction.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PassthroughControllerFunction_calculate(int argc, VALUE *argv, VALUE self) {
  Ogre::PassthroughControllerFunction *arg1 = (Ogre::PassthroughControllerFunction *) 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_Ogre__PassthroughControllerFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PassthroughControllerFunction *","calculate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PassthroughControllerFunction * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","calculate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)(arg1)->calculate(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PassthroughControllerFunction(Ogre::PassthroughControllerFunction *arg1) {
    delete arg1;
}

swig_class SwigClassAnimationControllerFunction;

SWIGINTERN VALUE
_wrap_new_AnimationControllerFunction__SWIG_0(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 = "Ogre::AnimationControllerFunction";
  Ogre::AnimationControllerFunction *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","Ogre::AnimationControllerFunction", 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","Ogre::AnimationControllerFunction", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::AnimationControllerFunction *)new Ogre::AnimationControllerFunction(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_AnimationControllerFunction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AnimationControllerFunction";
  Ogre::AnimationControllerFunction *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","Ogre::AnimationControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  result = (Ogre::AnimationControllerFunction *)new Ogre::AnimationControllerFunction(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_AnimationControllerFunction(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;
    {
      int res = SWIG_AsVal_float(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_AnimationControllerFunction__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_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_AnimationControllerFunction__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "AnimationControllerFunction.new", 
    "    AnimationControllerFunction.new(Ogre::Real sequenceTime, Ogre::Real timeOffset)\n"
    "    AnimationControllerFunction.new(Ogre::Real sequenceTime)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationControllerFunction_calculate(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationControllerFunction *arg1 = (Ogre::AnimationControllerFunction *) 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_Ogre__AnimationControllerFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationControllerFunction *","calculate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationControllerFunction * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","calculate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)(arg1)->calculate(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationControllerFunction_setTime(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationControllerFunction *arg1 = (Ogre::AnimationControllerFunction *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimationControllerFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationControllerFunction *","setTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationControllerFunction * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTime", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTime(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AnimationControllerFunction_setSequenceTime(int argc, VALUE *argv, VALUE self) {
  Ogre::AnimationControllerFunction *arg1 = (Ogre::AnimationControllerFunction *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__AnimationControllerFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AnimationControllerFunction *","setSequenceTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AnimationControllerFunction * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSequenceTime", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSequenceTime(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AnimationControllerFunction(Ogre::AnimationControllerFunction *arg1) {
    delete arg1;
}

swig_class SwigClassScaleControllerFunction;

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

SWIGINTERN VALUE
_wrap_new_ScaleControllerFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  bool arg2 ;
  float val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ScaleControllerFunction";
  Ogre::ScaleControllerFunction *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","Ogre::ScaleControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::ScaleControllerFunction", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::ScaleControllerFunction *)new Ogre::ScaleControllerFunction(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScaleControllerFunction_calculate(int argc, VALUE *argv, VALUE self) {
  Ogre::ScaleControllerFunction *arg1 = (Ogre::ScaleControllerFunction *) 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_Ogre__ScaleControllerFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScaleControllerFunction *","calculate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScaleControllerFunction * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","calculate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)(arg1)->calculate(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScaleControllerFunction(Ogre::ScaleControllerFunction *arg1) {
    delete arg1;
}

swig_class SwigClassWaveformControllerFunction;

SWIGINTERN VALUE
_wrap_new_WaveformControllerFunction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformType arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  bool arg6 ;
  Ogre::Real arg7 ;
  int val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::WaveformControllerFunction";
  Ogre::WaveformControllerFunction *result = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::WaveformType","Ogre::WaveformControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::WaveformType >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 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","Ogre::WaveformControllerFunction", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::WaveformControllerFunction", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_float(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 7, argv[6] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_WaveformControllerFunction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformType arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  bool arg6 ;
  int val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::WaveformControllerFunction";
  Ogre::WaveformControllerFunction *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::WaveformType","Ogre::WaveformControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::WaveformType >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 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","Ogre::WaveformControllerFunction", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_bool(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","Ogre::WaveformControllerFunction", 6, argv[5] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4,arg5,arg6);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_WaveformControllerFunction__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformType arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  int val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::WaveformControllerFunction";
  Ogre::WaveformControllerFunction *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::WaveformType","Ogre::WaveformControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::WaveformType >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 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","Ogre::WaveformControllerFunction", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_WaveformControllerFunction__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformType arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::WaveformControllerFunction";
  Ogre::WaveformControllerFunction *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::WaveformType","Ogre::WaveformControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::WaveformType >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 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","Ogre::WaveformControllerFunction", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_WaveformControllerFunction__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformType arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::WaveformControllerFunction";
  Ogre::WaveformControllerFunction *result = 0 ;
  
  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( "", "Ogre::WaveformType","Ogre::WaveformControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::WaveformType >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 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","Ogre::WaveformControllerFunction", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_WaveformControllerFunction__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformType arg1 ;
  Ogre::Real arg2 ;
  int val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::WaveformControllerFunction";
  Ogre::WaveformControllerFunction *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( "", "Ogre::WaveformType","Ogre::WaveformControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::WaveformType >(val1);
  ecode2 = SWIG_AsVal_float(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::WaveformControllerFunction", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_WaveformControllerFunction__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformType arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::WaveformControllerFunction";
  Ogre::WaveformControllerFunction *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( "", "Ogre::WaveformType","Ogre::WaveformControllerFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::WaveformType >(val1);
  result = (Ogre::WaveformControllerFunction *)new Ogre::WaveformControllerFunction(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_WaveformControllerFunction(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs;
  if (argc > 7) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_WaveformControllerFunction__SWIG_6(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_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_WaveformControllerFunction__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_int(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_WaveformControllerFunction__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_int(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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_WaveformControllerFunction__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    {
      int res = SWIG_AsVal_int(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_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_new_WaveformControllerFunction__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    {
      int res = SWIG_AsVal_int(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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_new_WaveformControllerFunction__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    {
      int res = SWIG_AsVal_int(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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_new_WaveformControllerFunction__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "WaveformControllerFunction.new", 
    "    WaveformControllerFunction.new(Ogre::WaveformType wType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase, Ogre::Real amplitude, bool deltaInput, Ogre::Real dutyCycle)\n"
    "    WaveformControllerFunction.new(Ogre::WaveformType wType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase, Ogre::Real amplitude, bool deltaInput)\n"
    "    WaveformControllerFunction.new(Ogre::WaveformType wType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase, Ogre::Real amplitude)\n"
    "    WaveformControllerFunction.new(Ogre::WaveformType wType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase)\n"
    "    WaveformControllerFunction.new(Ogre::WaveformType wType, Ogre::Real base, Ogre::Real frequency)\n"
    "    WaveformControllerFunction.new(Ogre::WaveformType wType, Ogre::Real base)\n"
    "    WaveformControllerFunction.new(Ogre::WaveformType wType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WaveformControllerFunction_calculate(int argc, VALUE *argv, VALUE self) {
  Ogre::WaveformControllerFunction *arg1 = (Ogre::WaveformControllerFunction *) 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_Ogre__WaveformControllerFunction, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WaveformControllerFunction *","calculate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WaveformControllerFunction * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","calculate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)(arg1)->calculate(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_WaveformControllerFunction(Ogre::WaveformControllerFunction *arg1) {
    delete arg1;
}

swig_class SwigClassControllerManager;

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

SWIGINTERN VALUE
_wrap_new_ControllerManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ControllerManager";
  Ogre::ControllerManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ControllerManager *)new Ogre::ControllerManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ControllerManager(Ogre::ControllerManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ControllerManager_createController(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::ControllerValueRealPtr *arg2 = 0 ;
  Ogre::ControllerValueRealPtr *arg3 = 0 ;
  Ogre::ControllerFunctionRealPtr *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createController", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ControllerValueRealPtr const &","createController", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ControllerValueRealPtr const &","createController", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ControllerValueRealPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ControllerValueRealPtr const &","createController", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ControllerValueRealPtr const &","createController", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ControllerValueRealPtr * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ControllerFunctionRealPtr const &","createController", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ControllerFunctionRealPtr const &","createController", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ControllerFunctionRealPtr * >(argp4);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createController((Ogre::ControllerValueRealPtr const &)*arg2,(Ogre::ControllerValueRealPtr const &)*arg3,(Ogre::ControllerFunctionRealPtr const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createFrameTimePassthroughController(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::ControllerValueRealPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createFrameTimePassthroughController", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ControllerValueRealPtr const &","createFrameTimePassthroughController", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ControllerValueRealPtr const &","createFrameTimePassthroughController", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ControllerValueRealPtr * >(argp2);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createFrameTimePassthroughController((Ogre::ControllerValueRealPtr const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_clearControllers(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","clearControllers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  (arg1)->clearControllers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_updateAllControllers(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","updateAllControllers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  (arg1)->updateAllControllers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_getFrameTimeSource(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ControllerValueRealPtr *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager const *","getFrameTimeSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  result = (Ogre::ControllerValueRealPtr *) &((Ogre::ControllerManager const *)arg1)->getFrameTimeSource();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerValueT_float_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_getPassthroughControllerFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ControllerFunctionRealPtr *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager const *","getPassthroughControllerFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  result = (Ogre::ControllerFunctionRealPtr *) &((Ogre::ControllerManager const *)arg1)->getPassthroughControllerFunction();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ControllerFunctionT_float_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureAnimator(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureAnimator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureAnimator", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createTextureAnimator", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureAnimator(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureUVScroller(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureUVScroller", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureUVScroller", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createTextureUVScroller", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureUVScroller(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureUScroller(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureUScroller", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureUScroller", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createTextureUScroller", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureUScroller(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureVScroller(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureVScroller", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureVScroller", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createTextureVScroller", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureVScroller(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureRotater(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureRotater", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureRotater", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createTextureRotater", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureRotater(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureWaveTransformer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg3 ;
  Ogre::WaveformType arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  Ogre::Controller< Ogre::Real > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureWaveTransformer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureWaveTransformer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","createTextureWaveTransformer", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::WaveformType","createTextureWaveTransformer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::WaveformType >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureWaveTransformer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg3 ;
  Ogre::WaveformType arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  Ogre::Controller< Ogre::Real > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureWaveTransformer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureWaveTransformer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","createTextureWaveTransformer", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::WaveformType","createTextureWaveTransformer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::WaveformType >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureWaveTransformer__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg3 ;
  Ogre::WaveformType arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  Ogre::Controller< Ogre::Real > *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureWaveTransformer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureWaveTransformer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","createTextureWaveTransformer", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::WaveformType","createTextureWaveTransformer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::WaveformType >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureWaveTransformer__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg3 ;
  Ogre::WaveformType arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureWaveTransformer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureWaveTransformer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","createTextureWaveTransformer", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::WaveformType","createTextureWaveTransformer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::WaveformType >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createTextureWaveTransformer", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createTextureWaveTransformer__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  Ogre::TextureUnitState::TextureTransformType arg3 ;
  Ogre::WaveformType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createTextureWaveTransformer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","createTextureWaveTransformer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::TextureTransformType","createTextureWaveTransformer", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::TextureUnitState::TextureTransformType >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::WaveformType","createTextureWaveTransformer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::WaveformType >(val4);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createTextureWaveTransformer(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ControllerManager_createTextureWaveTransformer(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 9) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ControllerManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
      _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_ControllerManager_createTextureWaveTransformer__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ControllerManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
      _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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ControllerManager_createTextureWaveTransformer__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ControllerManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
      _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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ControllerManager_createTextureWaveTransformer__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ControllerManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
      _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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ControllerManager_createTextureWaveTransformer__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ControllerManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TextureUnitState, 0);
      _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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_ControllerManager_createTextureWaveTransformer__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "ControllerManager.createTextureWaveTransformer", 
    "    Ogre::Controller< Ogre::Real > * ControllerManager.createTextureWaveTransformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase, Ogre::Real amplitude)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.createTextureWaveTransformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType, Ogre::Real base, Ogre::Real frequency, Ogre::Real phase)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.createTextureWaveTransformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType, Ogre::Real base, Ogre::Real frequency)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.createTextureWaveTransformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType, Ogre::Real base)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.createTextureWaveTransformer(Ogre::TextureUnitState *layer, Ogre::TextureUnitState::TextureTransformType ttype, Ogre::WaveformType waveType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createGpuProgramTimerParam__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  size_t arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createGpuProgramTimerParam", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","createGpuProgramTimerParam", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","createGpuProgramTimerParam", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createGpuProgramTimerParam", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","createGpuProgramTimerParam", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createGpuProgramTimerParam(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_createGpuProgramTimerParam__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::Controller< Ogre::Real > *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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","createGpuProgramTimerParam", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","createGpuProgramTimerParam", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","createGpuProgramTimerParam", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createGpuProgramTimerParam", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::Controller< Ogre::Real > *)(arg1)->createGpuProgramTimerParam(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ControllerManager_createGpuProgramTimerParam(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_Ogre__ControllerManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ControllerManager_createGpuProgramTimerParam__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ControllerManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_ControllerManager_createGpuProgramTimerParam__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ControllerManager.createGpuProgramTimerParam", 
    "    Ogre::Controller< Ogre::Real > * ControllerManager.createGpuProgramTimerParam(Ogre::GpuProgramParametersSharedPtr params, size_t paramIndex, Ogre::Real timeFactor)\n"
    "    Ogre::Controller< Ogre::Real > * ControllerManager.createGpuProgramTimerParam(Ogre::GpuProgramParametersSharedPtr params, size_t paramIndex)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_destroyController(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::Controller< Ogre::Real > *arg2 = (Ogre::Controller< Ogre::Real > *) 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","destroyController", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ControllerT_float_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Controller< Ogre::Real > *","destroyController", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Controller< Ogre::Real > * >(argp2);
  (arg1)->destroyController(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_getTimeFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager const *","getTimeFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  result = (Ogre::Real)((Ogre::ControllerManager const *)arg1)->getTimeFactor();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_setTimeFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","setTimeFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTimeFactor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTimeFactor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_getFrameDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager const *","getFrameDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  result = (Ogre::Real)((Ogre::ControllerManager const *)arg1)->getFrameDelay();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_setFrameDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","setFrameDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFrameDelay", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setFrameDelay(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_getElapsedTime(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager const *","getElapsedTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  result = (Ogre::Real)((Ogre::ControllerManager const *)arg1)->getElapsedTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_setElapsedTime(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *arg1 = (Ogre::ControllerManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ControllerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ControllerManager *","setElapsedTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ControllerManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setElapsedTime", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setElapsedTime(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ControllerManager *) &Ogre::ControllerManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ControllerManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ControllerManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ControllerManager *)Ogre::ControllerManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ControllerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPolygon;

SWIGINTERN VALUE
_wrap_new_Polygon__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Polygon";
  Ogre::Polygon *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Polygon *)new Ogre::Polygon();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Polygon(Ogre::Polygon *arg1) {
    delete arg1;
}

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

SWIGINTERN VALUE
_wrap_new_Polygon__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Polygon";
  Ogre::Polygon *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__Polygon,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon const &","Ogre::Polygon", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Polygon const &","Ogre::Polygon", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  result = (Ogre::Polygon *)new Ogre::Polygon((Ogre::Polygon const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Polygon(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_Polygon__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Polygon, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Polygon__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Polygon.new", 
    "    Polygon.new()\n"
    "    Polygon.new(Ogre::Polygon const &cpy)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_insertVertex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon *","insertVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(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 &","insertVertex", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","insertVertex", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","insertVertex", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->insertVertex((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_insertVertex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  Ogre::Vector3 *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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon *","insertVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(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 &","insertVertex", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","insertVertex", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->insertVertex((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Polygon_insertVertex(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_Ogre__Polygon, 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_Polygon_insertVertex__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Polygon, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Polygon_insertVertex__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Polygon.insertVertex", 
    "    void Polygon.insertVertex(Ogre::Vector3 const &vdata, size_t vertexIndex)\n"
    "    void Polygon.insertVertex(Ogre::Vector3 const &vdata)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_getVertex(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon const *","getVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getVertex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Vector3 *) &((Ogre::Polygon const *)arg1)->getVertex(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_setVertex(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon *","setVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(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 &","setVertex", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setVertex", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setVertex", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setVertex((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_removeDuplicates(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon *","removeDuplicates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  (arg1)->removeDuplicates();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_getVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon const *","getVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  result = ((Ogre::Polygon const *)arg1)->getVertexCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_getNormal(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon const *","getNormal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Polygon const *)arg1)->getNormal();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_deleteVertex(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon *","deleteVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","deleteVertex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->deleteVertex(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_isPointInside(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  Ogre::Vector3 *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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon const *","isPointInside", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(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 &","isPointInside", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","isPointInside", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (bool)((Ogre::Polygon const *)arg1)->isPointInside((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_storeEdges(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  Ogre::Polygon::EdgeMap *arg2 = (Ogre::Polygon::EdgeMap *) 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon const *","storeEdges", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Polygon::EdgeMap *","storeEdges", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Polygon::EdgeMap * >(argp2);
  ((Ogre::Polygon const *)arg1)->storeEdges(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Polygon_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Polygon.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_Polygon___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::Polygon *arg1 = (Ogre::Polygon *) 0 ;
  Ogre::Polygon *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_Ogre__Polygon, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Polygon const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Polygon * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Polygon,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Polygon const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Polygon const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Polygon * >(argp2);
  result = (bool)((Ogre::Polygon const *)arg1)->operator ==((Ogre::Polygon const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassConvexBody;

SWIGINTERN VALUE
_wrap_new_ConvexBody__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ConvexBody";
  Ogre::ConvexBody *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ConvexBody *)new Ogre::ConvexBody();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ConvexBody(Ogre::ConvexBody *arg1) {
    delete arg1;
}

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

SWIGINTERN VALUE
_wrap_new_ConvexBody__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ConvexBody";
  Ogre::ConvexBody *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__ConvexBody,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const &","Ogre::ConvexBody", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ConvexBody const &","Ogre::ConvexBody", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  result = (Ogre::ConvexBody *)new Ogre::ConvexBody((Ogre::ConvexBody const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ConvexBody(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_ConvexBody__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_ConvexBody__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "ConvexBody.new", 
    "    ConvexBody.new()\n"
    "    ConvexBody.new(Ogre::ConvexBody const &cpy)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_define__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::Frustum *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Frustum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Frustum const &","define", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Frustum const &","define", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Frustum * >(argp2);
  (arg1)->define((Ogre::Frustum const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_define__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","define", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","define", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->define((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConvexBody_define(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_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConvexBody_define__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConvexBody_define__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ConvexBody.define", 
    "    void ConvexBody.define(Ogre::Frustum const &frustum)\n"
    "    void ConvexBody.define(Ogre::AxisAlignedBox const &aab)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_clip__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::Frustum *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","clip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Frustum,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Frustum const &","clip", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Frustum const &","clip", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Frustum * >(argp2);
  (arg1)->clip((Ogre::Frustum const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_clip__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","clip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","clip", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","clip", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->clip((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_clip__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::ConvexBody *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","clip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ConvexBody,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ConvexBody const &","clip", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ConvexBody const &","clip", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ConvexBody * >(argp2);
  (arg1)->clip((Ogre::ConvexBody const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_clip__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::Plane *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","clip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","clip", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","clip", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","clip", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->clip((Ogre::Plane const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_clip__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::Plane *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","clip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const &","clip", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","clip", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  (arg1)->clip((Ogre::Plane const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ConvexBody_clip(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_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Frustum, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConvexBody_clip__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConvexBody_clip__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ConvexBody, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConvexBody_clip__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ConvexBody_clip__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ConvexBody, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ConvexBody_clip__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ConvexBody.clip", 
    "    void ConvexBody.clip(Ogre::Frustum const &frustum)\n"
    "    void ConvexBody.clip(Ogre::AxisAlignedBox const &aab)\n"
    "    void ConvexBody.clip(Ogre::ConvexBody const &body)\n"
    "    void ConvexBody.clip(Ogre::Plane const &pl, bool keepNegative)\n"
    "    void ConvexBody.clip(Ogre::Plane const &pl)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_extend(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::Vector3 *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","extend", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(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 &","extend", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","extend", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->extend((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_getPolygonCount(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","getPolygonCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  result = ((Ogre::ConvexBody const *)arg1)->getPolygonCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_getVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","getVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getVertexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::ConvexBody const *)arg1)->getVertexCount(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_getPolygon(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Polygon *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","getPolygon", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getPolygon", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Polygon *) &((Ogre::ConvexBody const *)arg1)->getPolygon(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Polygon, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_getVertex(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::Vector3 *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","getVertex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getVertex", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getVertex", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::Vector3 *) &((Ogre::ConvexBody const *)arg1)->getVertex(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_getNormal(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","getNormal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getNormal", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Vector3 *) &(arg1)->getNormal(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_getAABB(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","getAABB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  result = ((Ogre::ConvexBody const *)arg1)->getAABB();
  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_ConvexBody_hasClosedHull(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","hasClosedHull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  result = (bool)((Ogre::ConvexBody const *)arg1)->hasClosedHull();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_mergePolygons(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody *","mergePolygons", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  (arg1)->mergePolygons();
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ConvexBody.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_ConvexBody___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 0 ;
  Ogre::ConvexBody *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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ConvexBody,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ConvexBody const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ConvexBody const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ConvexBody * >(argp2);
  result = (bool)((Ogre::ConvexBody const *)arg1)->operator ==((Ogre::ConvexBody const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody_logInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::ConvexBody *arg1 = (Ogre::ConvexBody *) 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_Ogre__ConvexBody, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConvexBody const *","logInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConvexBody * >(argp1);
  ((Ogre::ConvexBody const *)arg1)->logInfo();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody__initialisePool(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::ConvexBody::_initialisePool();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConvexBody__destroyPool(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::ConvexBody::_destroyPool();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassCustomCompositionPass;

SWIGINTERN VALUE
_wrap_CustomCompositionPass_createOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::CustomCompositionPass *arg1 = (Ogre::CustomCompositionPass *) 0 ;
  Ogre::CompositorInstance *arg2 = (Ogre::CompositorInstance *) 0 ;
  Ogre::CompositionPass *arg3 = (Ogre::CompositionPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::CompositorInstance::RenderSystemOperation *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_Ogre__CustomCompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CustomCompositionPass *","createOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CustomCompositionPass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorInstance, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorInstance *","createOperation", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorInstance * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__CompositionPass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::CompositionPass const *","createOperation", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::CompositionPass * >(argp3);
  result = (Ogre::CompositorInstance::RenderSystemOperation *)(arg1)->createOperation(arg2,(Ogre::CompositionPass const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorInstance__RenderSystemOperation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassImageCodec;

SWIGINTERN void
free_Ogre_ImageCodec(Ogre::ImageCodec *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ImageCodec_getDataType(int argc, VALUE *argv, VALUE self) {
  Ogre::ImageCodec *arg1 = (Ogre::ImageCodec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__ImageCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ImageCodec const *","getDataType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ImageCodec * >(argp1);
  result = ((Ogre::ImageCodec const *)arg1)->getDataType();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDDSCodec;

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

SWIGINTERN VALUE
_wrap_new_DDSCodec(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DDSCodec";
  Ogre::DDSCodec *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DDSCodec *)new Ogre::DDSCodec();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DDSCodec(Ogre::DDSCodec *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DDSCodec_code(int argc, VALUE *argv, VALUE self) {
  Ogre::DDSCodec *arg1 = (Ogre::DDSCodec *) 0 ;
  Ogre::MemoryDataStreamPtr *arg2 = 0 ;
  Ogre::Codec::CodecDataPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__DDSCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DDSCodec const *","code", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DDSCodec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MemoryDataStreamPtr &","code", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MemoryDataStreamPtr &","code", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MemoryDataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__CodecData_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Codec::CodecDataPtr &","code", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Codec::CodecDataPtr &","code", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Codec::CodecDataPtr * >(argp3);
  result = ((Ogre::DDSCodec const *)arg1)->code(*arg2,*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DDSCodec_codeToFile(int argc, VALUE *argv, VALUE self) {
  Ogre::DDSCodec *arg1 = (Ogre::DDSCodec *) 0 ;
  Ogre::MemoryDataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Codec::CodecDataPtr *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__DDSCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DDSCodec const *","codeToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DDSCodec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MemoryDataStreamPtr &","codeToFile", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MemoryDataStreamPtr &","codeToFile", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MemoryDataStreamPtr * >(argp2);
  {
    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 &","codeToFile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","codeToFile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__CodecData_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Codec::CodecDataPtr &","codeToFile", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Codec::CodecDataPtr &","codeToFile", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Codec::CodecDataPtr * >(argp4);
  ((Ogre::DDSCodec const *)arg1)->codeToFile(*arg2,(Ogre::String const &)*arg3,*arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DDSCodec_decode(int argc, VALUE *argv, VALUE self) {
  Ogre::DDSCodec *arg1 = (Ogre::DDSCodec *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::MemoryDataStream >,Ogre::SharedPtr< Ogre::Codec::CodecData > > > 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_Ogre__DDSCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DDSCodec const *","decode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DDSCodec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","decode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","decode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = ((Ogre::DDSCodec const *)arg1)->decode(*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Codec::DecodeResult(static_cast< const Ogre::Codec::DecodeResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DDSCodec_magicNumberToFileExt(int argc, VALUE *argv, VALUE self) {
  Ogre::DDSCodec *arg1 = (Ogre::DDSCodec *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_Ogre__DDSCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DDSCodec const *","magicNumberToFileExt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DDSCodec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","magicNumberToFileExt", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","magicNumberToFileExt", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = ((Ogre::DDSCodec const *)arg1)->magicNumberToFileExt((char const *)arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DDSCodec_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::DDSCodec *arg1 = (Ogre::DDSCodec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__DDSCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DDSCodec const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DDSCodec * >(argp1);
  result = ((Ogre::DDSCodec const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DDSCodec_startup(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::DDSCodec::startup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DDSCodec_shutdown(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::DDSCodec::shutdown();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderToVertexBuffer;

SWIGINTERN void
free_Ogre_RenderToVertexBuffer(Ogre::RenderToVertexBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_getVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","getVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  result = (Ogre::VertexDeclaration *)(arg1)->getVertexDeclaration();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_getMaxVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer const *","getMaxVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  result = (unsigned int)((Ogre::RenderToVertexBuffer const *)arg1)->getMaxVertexCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_setMaxVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","setMaxVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(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","setMaxVertexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setMaxVertexCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_getOperationType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderOperation::OperationType 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer const *","getOperationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  result = (Ogre::RenderOperation::OperationType)((Ogre::RenderToVertexBuffer const *)arg1)->getOperationType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_setOperationType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  Ogre::RenderOperation::OperationType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","setOperationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::RenderOperation::OperationType","setOperationType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::RenderOperation::OperationType >(val2);
  (arg1)->setOperationType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_setResetsEveryUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","setResetsEveryUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setResetsEveryUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setResetsEveryUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_getResetsEveryUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer const *","getResetsEveryUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  result = (bool)((Ogre::RenderToVertexBuffer const *)arg1)->getResetsEveryUpdate();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  Ogre::RenderOperation *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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_update(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","update", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->update(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_setSourceRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","setSourceRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","setSourceRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  (arg1)->setSourceRenderable(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_getSourceRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Renderable *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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer const *","getSourceRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  result = (Ogre::Renderable *)((Ogre::RenderToVertexBuffer const *)arg1)->getSourceRenderable();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_getRenderToBufferMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","getRenderToBufferMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(argp1);
  result = (Ogre::MaterialPtr *) &(arg1)->getRenderToBufferMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderToVertexBuffer_setRenderToBufferMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderToVertexBuffer *arg1 = (Ogre::RenderToVertexBuffer *) 0 ;
  Ogre::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_Ogre__RenderToVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderToVertexBuffer *","setRenderToBufferMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderToVertexBuffer * >(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( "", "Ogre::String const &","setRenderToBufferMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setRenderToBufferMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setRenderToBufferMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassHardwareBufferLicensee;

SWIGINTERN void
free_Ogre_HardwareBufferLicensee(Ogre::HardwareBufferLicensee *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwareBufferLicensee_licenseExpired(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferLicensee *arg1 = (Ogre::HardwareBufferLicensee *) 0 ;
  Ogre::HardwareBuffer *arg2 = (Ogre::HardwareBuffer *) 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_Ogre__HardwareBufferLicensee, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferLicensee *","licenseExpired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferLicensee * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","licenseExpired", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareBuffer * >(argp2);
  (arg1)->licenseExpired(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassTempBlendedBufferInfo;

SWIGINTERN void
free_Ogre_TempBlendedBufferInfo(Ogre::TempBlendedBufferInfo *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_extractFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo *","extractFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData const *","extractFrom", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  (arg1)->extractFrom((Ogre::VertexData const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_checkoutTempCopies__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo *","checkoutTempCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkoutTempCopies", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","checkoutTempCopies", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->checkoutTempCopies(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_checkoutTempCopies__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo *","checkoutTempCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkoutTempCopies", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->checkoutTempCopies(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_checkoutTempCopies__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo *","checkoutTempCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  (arg1)->checkoutTempCopies();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TempBlendedBufferInfo_checkoutTempCopies(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_Ogre__TempBlendedBufferInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TempBlendedBufferInfo_checkoutTempCopies__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TempBlendedBufferInfo_checkoutTempCopies__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TempBlendedBufferInfo_checkoutTempCopies__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TempBlendedBufferInfo.checkoutTempCopies", 
    "    void TempBlendedBufferInfo.checkoutTempCopies(bool positions, bool normals)\n"
    "    void TempBlendedBufferInfo.checkoutTempCopies(bool positions)\n"
    "    void TempBlendedBufferInfo.checkoutTempCopies()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_bindTempCopies(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo *","bindTempCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","bindTempCopies", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","bindTempCopies", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->bindTempCopies(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_licenseExpired(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 0 ;
  Ogre::HardwareBuffer *arg2 = (Ogre::HardwareBuffer *) 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo *","licenseExpired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer *","licenseExpired", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareBuffer * >(argp2);
  (arg1)->licenseExpired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_buffersCheckedOut__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo const *","buffersCheckedOut", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","buffersCheckedOut", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","buffersCheckedOut", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)((Ogre::TempBlendedBufferInfo const *)arg1)->buffersCheckedOut(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_buffersCheckedOut__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo const *","buffersCheckedOut", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","buffersCheckedOut", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (bool)((Ogre::TempBlendedBufferInfo const *)arg1)->buffersCheckedOut(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TempBlendedBufferInfo_buffersCheckedOut__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TempBlendedBufferInfo *arg1 = (Ogre::TempBlendedBufferInfo *) 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_Ogre__TempBlendedBufferInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TempBlendedBufferInfo const *","buffersCheckedOut", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TempBlendedBufferInfo * >(argp1);
  result = (bool)((Ogre::TempBlendedBufferInfo const *)arg1)->buffersCheckedOut();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TempBlendedBufferInfo_buffersCheckedOut(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_Ogre__TempBlendedBufferInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TempBlendedBufferInfo_buffersCheckedOut__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TempBlendedBufferInfo_buffersCheckedOut__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TempBlendedBufferInfo_buffersCheckedOut__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TempBlendedBufferInfo.buffersCheckedOut", 
    "    bool TempBlendedBufferInfo.buffersCheckedOut(bool positions, bool normals)\n"
    "    bool TempBlendedBufferInfo.buffersCheckedOut(bool positions)\n"
    "    bool TempBlendedBufferInfo.buffersCheckedOut()\n");
  
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TempBlendedBufferInfo(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TempBlendedBufferInfo";
  Ogre::TempBlendedBufferInfo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TempBlendedBufferInfo *)new Ogre::TempBlendedBufferInfo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


swig_class SwigClassHardwareBufferManagerBase;

SWIGINTERN void
free_Ogre_HardwareBufferManagerBase(Ogre::HardwareBufferManagerBase *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_createVertexBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr result;
  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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","createVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createVertexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createVertexBuffer", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->createVertexBuffer(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_createVertexBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","createVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createVertexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->createVertexBuffer(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManagerBase_createVertexBuffer(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 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_size_t(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_HardwareBufferManagerBase_createVertexBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 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_size_t(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_HardwareBufferManagerBase_createVertexBuffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManagerBase.createVertexBuffer", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.createVertexBuffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.createVertexBuffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_createIndexBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareIndexBuffer::IndexType arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareIndexBufferSharedPtr result;
  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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","createIndexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer::IndexType","createIndexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareIndexBuffer::IndexType >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createIndexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createIndexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createIndexBuffer", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->createIndexBuffer(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareIndexBufferSharedPtr(static_cast< const Ogre::HardwareIndexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_createIndexBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareIndexBuffer::IndexType arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::HardwareIndexBufferSharedPtr 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","createIndexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer::IndexType","createIndexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareIndexBuffer::IndexType >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createIndexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createIndexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->createIndexBuffer(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareIndexBufferSharedPtr(static_cast< const Ogre::HardwareIndexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManagerBase_createIndexBuffer(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_HardwareBufferManagerBase_createIndexBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_HardwareBufferManagerBase_createIndexBuffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManagerBase.createIndexBuffer", 
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManagerBase.createIndexBuffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManagerBase.createIndexBuffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_createRenderToVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::RenderToVertexBuffer > > 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","createRenderToVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  result = (arg1)->createRenderToVertexBuffer();
  vresult = SWIG_NewPointerObj((new Ogre::RenderToVertexBufferSharedPtr(static_cast< const Ogre::RenderToVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_createVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","createVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  result = (Ogre::VertexDeclaration *)(arg1)->createVertexDeclaration();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_destroyVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","destroyVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","destroyVertexDeclaration", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  (arg1)->destroyVertexDeclaration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_createVertexBufferBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexBufferBinding *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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","createVertexBufferBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  result = (Ogre::VertexBufferBinding *)(arg1)->createVertexBufferBinding();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_destroyVertexBufferBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::VertexBufferBinding *arg2 = (Ogre::VertexBufferBinding *) 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","destroyVertexBufferBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","destroyVertexBufferBinding", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp2);
  (arg1)->destroyVertexBufferBinding(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_registerVertexBufferSourceAndCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","registerVertexBufferSourceAndCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp3);
  (arg1)->registerVertexBufferSourceAndCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_allocateVertexBufferCopy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = 0 ;
  Ogre::HardwareBufferManagerBase::BufferLicenseType arg3 ;
  Ogre::HardwareBufferLicensee *arg4 = (Ogre::HardwareBufferLicensee *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr result;
  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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","allocateVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase::BufferLicenseType","allocateVertexBufferCopy", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::HardwareBufferManagerBase::BufferLicenseType >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareBufferLicensee *","allocateVertexBufferCopy", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareBufferLicensee * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","allocateVertexBufferCopy", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_allocateVertexBufferCopy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = 0 ;
  Ogre::HardwareBufferManagerBase::BufferLicenseType arg3 ;
  Ogre::HardwareBufferLicensee *arg4 = (Ogre::HardwareBufferLicensee *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","allocateVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase::BufferLicenseType","allocateVertexBufferCopy", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::HardwareBufferManagerBase::BufferLicenseType >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareBufferLicensee *","allocateVertexBufferCopy", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareBufferLicensee * >(argp4);
  result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManagerBase_allocateVertexBufferCopy(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HardwareBufferManagerBase_allocateVertexBufferCopy__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_HardwareBufferManagerBase_allocateVertexBufferCopy__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManagerBase.allocateVertexBufferCopy", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.allocateVertexBufferCopy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee, bool copyData)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManagerBase.allocateVertexBufferCopy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_releaseVertexBufferCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","releaseVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","releaseVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","releaseVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  (arg1)->releaseVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase_touchVertexBufferCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","touchVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","touchVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","touchVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  (arg1)->touchVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__freeUnusedBufferCopies(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","_freeUnusedBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  (arg1)->_freeUnusedBufferCopies();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__releaseBufferCopies__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","_releaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_releaseBufferCopies", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_releaseBufferCopies(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__releaseBufferCopies__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","_releaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  (arg1)->_releaseBufferCopies();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManagerBase__releaseBufferCopies(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_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HardwareBufferManagerBase__releaseBufferCopies__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HardwareBufferManagerBase__releaseBufferCopies__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManagerBase._releaseBufferCopies", 
    "    void HardwareBufferManagerBase._releaseBufferCopies(bool forceFreeUnused)\n"
    "    void HardwareBufferManagerBase._releaseBufferCopies()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__forceReleaseBufferCopies__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","_forceReleaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","_forceReleaseBufferCopies", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","_forceReleaseBufferCopies", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  (arg1)->_forceReleaseBufferCopies((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__forceReleaseBufferCopies__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBuffer *arg2 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","_forceReleaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer *","_forceReleaseBufferCopies", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp2);
  (arg1)->_forceReleaseBufferCopies(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManagerBase__forceReleaseBufferCopies(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_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwareBufferManagerBase__forceReleaseBufferCopies__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBuffer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwareBufferManagerBase__forceReleaseBufferCopies__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManagerBase._forceReleaseBufferCopies", 
    "    void HardwareBufferManagerBase._forceReleaseBufferCopies(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer)\n"
    "    void HardwareBufferManagerBase._forceReleaseBufferCopies(Ogre::HardwareVertexBuffer *sourceBuffer)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__notifyVertexBufferDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareVertexBuffer *arg2 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","_notifyVertexBufferDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer *","_notifyVertexBufferDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp2);
  (arg1)->_notifyVertexBufferDestroyed(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManagerBase__notifyIndexBufferDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  Ogre::HardwareIndexBuffer *arg2 = (Ogre::HardwareIndexBuffer *) 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_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","_notifyIndexBufferDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer *","_notifyIndexBufferDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareIndexBuffer * >(argp2);
  (arg1)->_notifyIndexBufferDestroyed(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassHardwareBufferManager;

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

SWIGINTERN VALUE
_wrap_new_HardwareBufferManager(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::HardwareBufferManager";
  Ogre::HardwareBufferManager *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__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","Ogre::HardwareBufferManager", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  result = (Ogre::HardwareBufferManager *)new Ogre::HardwareBufferManager(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_HardwareBufferManager(Ogre::HardwareBufferManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwareBufferManager_createVertexBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr result;
  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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","createVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createVertexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createVertexBuffer", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->createVertexBuffer(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_createVertexBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","createVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createVertexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->createVertexBuffer(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManager_createVertexBuffer(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 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_size_t(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_HardwareBufferManager_createVertexBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 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_size_t(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_HardwareBufferManager_createVertexBuffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManager.createVertexBuffer", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.createVertexBuffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.createVertexBuffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_createIndexBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareIndexBuffer::IndexType arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareIndexBufferSharedPtr result;
  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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","createIndexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer::IndexType","createIndexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareIndexBuffer::IndexType >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createIndexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createIndexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createIndexBuffer", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->createIndexBuffer(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareIndexBufferSharedPtr(static_cast< const Ogre::HardwareIndexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_createIndexBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareIndexBuffer::IndexType arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::HardwareIndexBufferSharedPtr 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","createIndexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer::IndexType","createIndexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareIndexBuffer::IndexType >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createIndexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createIndexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->createIndexBuffer(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareIndexBufferSharedPtr(static_cast< const Ogre::HardwareIndexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManager_createIndexBuffer(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_HardwareBufferManager_createIndexBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_HardwareBufferManager_createIndexBuffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManager.createIndexBuffer", 
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManager.createIndexBuffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareIndexBufferSharedPtr HardwareBufferManager.createIndexBuffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_createRenderToVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::RenderToVertexBuffer > > 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","createRenderToVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  result = (arg1)->createRenderToVertexBuffer();
  vresult = SWIG_NewPointerObj((new Ogre::RenderToVertexBufferSharedPtr(static_cast< const Ogre::RenderToVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_createVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexDeclaration *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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","createVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  result = (Ogre::VertexDeclaration *)(arg1)->createVertexDeclaration();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_destroyVertexDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::VertexDeclaration *arg2 = (Ogre::VertexDeclaration *) 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","destroyVertexDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","destroyVertexDeclaration", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexDeclaration * >(argp2);
  (arg1)->destroyVertexDeclaration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_createVertexBufferBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexBufferBinding *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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","createVertexBufferBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  result = (Ogre::VertexBufferBinding *)(arg1)->createVertexBufferBinding();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_destroyVertexBufferBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::VertexBufferBinding *arg2 = (Ogre::VertexBufferBinding *) 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","destroyVertexBufferBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexBufferBinding, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBufferBinding *","destroyVertexBufferBinding", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBufferBinding * >(argp2);
  (arg1)->destroyVertexBufferBinding(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_registerVertexBufferSourceAndCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","registerVertexBufferSourceAndCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","registerVertexBufferSourceAndCopy", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp3);
  (arg1)->registerVertexBufferSourceAndCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_allocateVertexBufferCopy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = 0 ;
  Ogre::HardwareBufferManagerBase::BufferLicenseType arg3 ;
  Ogre::HardwareBufferLicensee *arg4 = (Ogre::HardwareBufferLicensee *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr result;
  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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","allocateVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase::BufferLicenseType","allocateVertexBufferCopy", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::HardwareBufferManagerBase::BufferLicenseType >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareBufferLicensee *","allocateVertexBufferCopy", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareBufferLicensee * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","allocateVertexBufferCopy", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_allocateVertexBufferCopy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *arg2 = 0 ;
  Ogre::HardwareBufferManagerBase::BufferLicenseType arg3 ;
  Ogre::HardwareBufferLicensee *arg4 = (Ogre::HardwareBufferLicensee *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","allocateVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","allocateVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase::BufferLicenseType","allocateVertexBufferCopy", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::HardwareBufferManagerBase::BufferLicenseType >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareBufferLicensee *","allocateVertexBufferCopy", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareBufferLicensee * >(argp4);
  result = (arg1)->allocateVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManager_allocateVertexBufferCopy(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HardwareBufferManager_allocateVertexBufferCopy__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareBufferLicensee, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_HardwareBufferManager_allocateVertexBufferCopy__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwareBufferManager.allocateVertexBufferCopy", 
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.allocateVertexBufferCopy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee, bool copyData)\n"
    "    Ogre::HardwareVertexBufferSharedPtr HardwareBufferManager.allocateVertexBufferCopy(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer, Ogre::HardwareBufferManagerBase::BufferLicenseType licenseType, Ogre::HardwareBufferLicensee *licensee)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_releaseVertexBufferCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","releaseVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","releaseVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","releaseVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  (arg1)->releaseVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_touchVertexBufferCopy(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","touchVertexBufferCopy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","touchVertexBufferCopy", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","touchVertexBufferCopy", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  (arg1)->touchVertexBufferCopy((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__freeUnusedBufferCopies(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","_freeUnusedBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  (arg1)->_freeUnusedBufferCopies();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__releaseBufferCopies__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","_releaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_releaseBufferCopies", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_releaseBufferCopies(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__releaseBufferCopies__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","_releaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  (arg1)->_releaseBufferCopies();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManager__releaseBufferCopies(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_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HardwareBufferManager__releaseBufferCopies__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HardwareBufferManager__releaseBufferCopies__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManager._releaseBufferCopies", 
    "    void HardwareBufferManager._releaseBufferCopies(bool forceFreeUnused)\n"
    "    void HardwareBufferManager._releaseBufferCopies()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__forceReleaseBufferCopies__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr *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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","_forceReleaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","_forceReleaseBufferCopies", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","_forceReleaseBufferCopies", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2);
  (arg1)->_forceReleaseBufferCopies((Ogre::HardwareVertexBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__forceReleaseBufferCopies__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBuffer *arg2 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","_forceReleaseBufferCopies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer *","_forceReleaseBufferCopies", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp2);
  (arg1)->_forceReleaseBufferCopies(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwareBufferManager__forceReleaseBufferCopies(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_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwareBufferManager__forceReleaseBufferCopies__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwareVertexBuffer, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwareBufferManager__forceReleaseBufferCopies__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwareBufferManager._forceReleaseBufferCopies", 
    "    void HardwareBufferManager._forceReleaseBufferCopies(Ogre::HardwareVertexBufferSharedPtr const &sourceBuffer)\n"
    "    void HardwareBufferManager._forceReleaseBufferCopies(Ogre::HardwareVertexBuffer *sourceBuffer)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__notifyVertexBufferDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareVertexBuffer *arg2 = (Ogre::HardwareVertexBuffer *) 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","_notifyVertexBufferDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBuffer *","_notifyVertexBufferDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareVertexBuffer * >(argp2);
  (arg1)->_notifyVertexBufferDestroyed(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager__notifyIndexBufferDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *arg1 = (Ogre::HardwareBufferManager *) 0 ;
  Ogre::HardwareIndexBuffer *arg2 = (Ogre::HardwareIndexBuffer *) 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_Ogre__HardwareBufferManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManager *","_notifyIndexBufferDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer *","_notifyIndexBufferDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HardwareIndexBuffer * >(argp2);
  (arg1)->_notifyIndexBufferDestroyed(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HardwareBufferManager *) &Ogre::HardwareBufferManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareBufferManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HardwareBufferManager *)Ogre::HardwareBufferManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HardwareBufferManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDefaultHardwareVertexBuffer;

SWIGINTERN VALUE
_wrap_new_DefaultHardwareVertexBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  Ogre::HardwareBuffer::Usage arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultHardwareVertexBuffer";
  Ogre::DefaultHardwareVertexBuffer *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::DefaultHardwareVertexBuffer", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::DefaultHardwareVertexBuffer", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","Ogre::DefaultHardwareVertexBuffer", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::HardwareBuffer::Usage >(val3);
  result = (Ogre::DefaultHardwareVertexBuffer *)new Ogre::DefaultHardwareVertexBuffer(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_DefaultHardwareVertexBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareBufferManagerBase *arg1 = (Ogre::HardwareBufferManagerBase *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultHardwareVertexBuffer";
  Ogre::DefaultHardwareVertexBuffer *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareBufferManagerBase *","Ogre::DefaultHardwareVertexBuffer", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::DefaultHardwareVertexBuffer", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::DefaultHardwareVertexBuffer", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","Ogre::DefaultHardwareVertexBuffer", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (Ogre::DefaultHardwareVertexBuffer *)new Ogre::DefaultHardwareVertexBuffer(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DefaultHardwareVertexBuffer(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 == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _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_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_DefaultHardwareVertexBuffer__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwareBufferManagerBase, 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_size_t(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_DefaultHardwareVertexBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "DefaultHardwareVertexBuffer.new", 
    "    DefaultHardwareVertexBuffer.new(size_t vertexSize, size_t numVertices, Ogre::HardwareBuffer::Usage usage)\n"
    "    DefaultHardwareVertexBuffer.new(Ogre::HardwareBufferManagerBase *mgr, size_t vertexSize, size_t numVertices, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultHardwareVertexBuffer(Ogre::DefaultHardwareVertexBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_readData(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareVertexBuffer *arg1 = (Ogre::DefaultHardwareVertexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__DefaultHardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareVertexBuffer *","readData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","readData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","readData", 4, argv[2] )); 
  }
  (arg1)->readData(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_writeData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareVertexBuffer *arg1 = (Ogre::DefaultHardwareVertexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__DefaultHardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareVertexBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","writeData", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_writeData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareVertexBuffer *arg1 = (Ogre::DefaultHardwareVertexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__DefaultHardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareVertexBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  (arg1)->writeData(arg2,arg3,(void const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultHardwareVertexBuffer_writeData(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareVertexBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DefaultHardwareVertexBuffer_writeData__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareVertexBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_DefaultHardwareVertexBuffer_writeData__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareVertexBuffer.writeData", 
    "    void DefaultHardwareVertexBuffer.writeData(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void DefaultHardwareVertexBuffer.writeData(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_lock(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareVertexBuffer *arg1 = (Ogre::DefaultHardwareVertexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::LockOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *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_Ogre__DefaultHardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareVertexBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareVertexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","lock", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","lock", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::LockOptions >(val4);
  result = (void *)(arg1)->lock(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareVertexBuffer_unlock(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareVertexBuffer *arg1 = (Ogre::DefaultHardwareVertexBuffer *) 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_Ogre__DefaultHardwareVertexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareVertexBuffer *","unlock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareVertexBuffer * >(argp1);
  (arg1)->unlock();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultHardwareIndexBuffer;

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

SWIGINTERN VALUE
_wrap_new_DefaultHardwareIndexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareIndexBuffer::IndexType arg1 ;
  size_t arg2 ;
  Ogre::HardwareBuffer::Usage arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultHardwareIndexBuffer";
  Ogre::DefaultHardwareIndexBuffer *result = 0 ;
  
  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( "", "Ogre::HardwareIndexBuffer::IndexType","Ogre::DefaultHardwareIndexBuffer", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::HardwareIndexBuffer::IndexType >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::DefaultHardwareIndexBuffer", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","Ogre::DefaultHardwareIndexBuffer", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::HardwareBuffer::Usage >(val3);
  result = (Ogre::DefaultHardwareIndexBuffer *)new Ogre::DefaultHardwareIndexBuffer(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultHardwareIndexBuffer(Ogre::DefaultHardwareIndexBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_readData(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareIndexBuffer *arg1 = (Ogre::DefaultHardwareIndexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__DefaultHardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareIndexBuffer *","readData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareIndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","readData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","readData", 4, argv[2] )); 
  }
  (arg1)->readData(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_writeData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareIndexBuffer *arg1 = (Ogre::DefaultHardwareIndexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__DefaultHardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareIndexBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareIndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","writeData", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_writeData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareIndexBuffer *arg1 = (Ogre::DefaultHardwareIndexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__DefaultHardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareIndexBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareIndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  (arg1)->writeData(arg2,arg3,(void const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultHardwareIndexBuffer_writeData(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareIndexBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DefaultHardwareIndexBuffer_writeData__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareIndexBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_DefaultHardwareIndexBuffer_writeData__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareIndexBuffer.writeData", 
    "    void DefaultHardwareIndexBuffer.writeData(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void DefaultHardwareIndexBuffer.writeData(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_lock(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareIndexBuffer *arg1 = (Ogre::DefaultHardwareIndexBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::LockOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *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_Ogre__DefaultHardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareIndexBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareIndexBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","lock", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","lock", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::LockOptions >(val4);
  result = (void *)(arg1)->lock(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareIndexBuffer_unlock(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareIndexBuffer *arg1 = (Ogre::DefaultHardwareIndexBuffer *) 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_Ogre__DefaultHardwareIndexBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareIndexBuffer *","unlock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareIndexBuffer * >(argp1);
  (arg1)->unlock();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultHardwareBufferManagerBase;

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

SWIGINTERN VALUE
_wrap_new_DefaultHardwareBufferManagerBase(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DefaultHardwareBufferManagerBase";
  Ogre::DefaultHardwareBufferManagerBase *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DefaultHardwareBufferManagerBase *)new Ogre::DefaultHardwareBufferManagerBase();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultHardwareBufferManagerBase(Ogre::DefaultHardwareBufferManagerBase *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_createVertexBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareBufferManagerBase *arg1 = (Ogre::DefaultHardwareBufferManagerBase *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr result;
  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_Ogre__DefaultHardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareBufferManagerBase *","createVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createVertexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createVertexBuffer", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->createVertexBuffer(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_createVertexBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareBufferManagerBase *arg1 = (Ogre::DefaultHardwareBufferManagerBase *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::HardwareVertexBufferSharedPtr 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_Ogre__DefaultHardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareBufferManagerBase *","createVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createVertexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createVertexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->createVertexBuffer(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareVertexBufferSharedPtr(static_cast< const Ogre::HardwareVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultHardwareBufferManagerBase_createVertexBuffer(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareBufferManagerBase, 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_size_t(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_DefaultHardwareBufferManagerBase_createVertexBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareBufferManagerBase, 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_size_t(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_DefaultHardwareBufferManagerBase_createVertexBuffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareBufferManagerBase.createVertexBuffer", 
    "    Ogre::HardwareVertexBufferSharedPtr DefaultHardwareBufferManagerBase.createVertexBuffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareVertexBufferSharedPtr DefaultHardwareBufferManagerBase.createVertexBuffer(size_t vertexSize, size_t numVerts, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_createIndexBuffer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareBufferManagerBase *arg1 = (Ogre::DefaultHardwareBufferManagerBase *) 0 ;
  Ogre::HardwareIndexBuffer::IndexType arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::HardwareIndexBufferSharedPtr result;
  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_Ogre__DefaultHardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareBufferManagerBase *","createIndexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer::IndexType","createIndexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareIndexBuffer::IndexType >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createIndexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createIndexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createIndexBuffer", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->createIndexBuffer(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareIndexBufferSharedPtr(static_cast< const Ogre::HardwareIndexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_createIndexBuffer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareBufferManagerBase *arg1 = (Ogre::DefaultHardwareBufferManagerBase *) 0 ;
  Ogre::HardwareIndexBuffer::IndexType arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::HardwareIndexBufferSharedPtr 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_Ogre__DefaultHardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareBufferManagerBase *","createIndexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareBufferManagerBase * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBuffer::IndexType","createIndexBuffer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareIndexBuffer::IndexType >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createIndexBuffer", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createIndexBuffer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->createIndexBuffer(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::HardwareIndexBufferSharedPtr(static_cast< const Ogre::HardwareIndexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultHardwareBufferManagerBase_createIndexBuffer(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_DefaultHardwareBufferManagerBase_createIndexBuffer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultHardwareBufferManagerBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_DefaultHardwareBufferManagerBase_createIndexBuffer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "DefaultHardwareBufferManagerBase.createIndexBuffer", 
    "    Ogre::HardwareIndexBufferSharedPtr DefaultHardwareBufferManagerBase.createIndexBuffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage, bool useShadowBuffer)\n"
    "    Ogre::HardwareIndexBufferSharedPtr DefaultHardwareBufferManagerBase.createIndexBuffer(Ogre::HardwareIndexBuffer::IndexType itype, size_t numIndexes, Ogre::HardwareBuffer::Usage usage)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultHardwareBufferManagerBase_createRenderToVertexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultHardwareBufferManagerBase *arg1 = (Ogre::DefaultHardwareBufferManagerBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::RenderToVertexBuffer > > 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_Ogre__DefaultHardwareBufferManagerBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultHardwareBufferManagerBase *","createRenderToVertexBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultHardwareBufferManagerBase * >(argp1);
  result = (arg1)->createRenderToVertexBuffer();
  vresult = SWIG_NewPointerObj((new Ogre::RenderToVertexBufferSharedPtr(static_cast< const Ogre::RenderToVertexBufferSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__RenderToVertexBuffer_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDefaultHardwareBufferManager;

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

SWIGINTERN VALUE
_wrap_new_DefaultHardwareBufferManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DefaultHardwareBufferManager";
  Ogre::DefaultHardwareBufferManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DefaultHardwareBufferManager *)new Ogre::DefaultHardwareBufferManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultHardwareBufferManager(Ogre::DefaultHardwareBufferManager *arg1) {
    delete arg1;
}

swig_class SwigClassDeflateStream;

SWIGINTERN VALUE
_wrap_new_DeflateStream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::DeflateStream";
  Ogre::DeflateStream *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__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::DeflateStream", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::DeflateStream", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::DataStreamPtr const &)*arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DeflateStream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DeflateStream";
  Ogre::DeflateStream *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__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::DataStreamPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DeflateStream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::DeflateStream";
  Ogre::DeflateStream *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::DeflateStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::DeflateStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::DeflateStream", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::DeflateStream", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_DeflateStream__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DeflateStream";
  Ogre::DeflateStream *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::DeflateStream", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::DeflateStream", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::DeflateStream", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = (Ogre::DeflateStream *)new Ogre::DeflateStream((Ogre::String const &)*arg1,(Ogre::DataStreamPtr const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DeflateStream(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DeflateStream__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_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_new_DeflateStream__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_DeflateStream__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_new_DeflateStream__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "DeflateStream.new", 
    "    DeflateStream.new(Ogre::DataStreamPtr const &compressedStream, Ogre::String const &tmpFileName)\n"
    "    DeflateStream.new(Ogre::DataStreamPtr const &compressedStream)\n"
    "    DeflateStream.new(Ogre::String const &name, Ogre::DataStreamPtr const &compressedStream, Ogre::String const &tmpFileName)\n"
    "    DeflateStream.new(Ogre::String const &name, Ogre::DataStreamPtr const &compressedStream)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_DeflateStream(Ogre::DeflateStream *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DeflateStream_isCompressedStreamValid(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream const *","isCompressedStreamValid", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  result = (bool)((Ogre::DeflateStream const *)arg1)->isCompressedStreamValid();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DeflateStream_read(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","read", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->read(arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DeflateStream_write(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","write", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (arg1)->write((void const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DeflateStream_skip(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream *","skip", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","skip", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  (arg1)->skip(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DeflateStream_seek(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream *","seek", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","seek", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->seek(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DeflateStream_tell(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream const *","tell", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  result = ((Ogre::DeflateStream const *)arg1)->tell();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DeflateStream_eof(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream const *","eof", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  result = (bool)((Ogre::DeflateStream const *)arg1)->eof();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DeflateStream_close(int argc, VALUE *argv, VALUE self) {
  Ogre::DeflateStream *arg1 = (Ogre::DeflateStream *) 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_Ogre__DeflateStream, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DeflateStream *","close", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DeflateStream * >(argp1);
  (arg1)->close();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDepthBuffer;

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

SWIGINTERN VALUE
_wrap_new_DepthBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::uint16 arg1 ;
  Ogre::uint16 arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  Ogre::uint32 arg5 ;
  Ogre::String *arg6 = 0 ;
  bool arg7 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  bool val7 ;
  int ecode7 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DepthBuffer";
  Ogre::DepthBuffer *result = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::DepthBuffer", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint16 >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::DepthBuffer", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::DepthBuffer", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::DepthBuffer", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::DepthBuffer", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::uint32 >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::DepthBuffer", 6, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::DepthBuffer", 6, argv[5])); 
    }
    arg6 = ptr;
  }
  ecode7 = SWIG_AsVal_bool(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","Ogre::DepthBuffer", 7, argv[6] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (Ogre::DepthBuffer *)new Ogre::DepthBuffer(arg1,arg2,arg3,arg4,arg5,(Ogre::String const &)*arg6,arg7);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return self;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN void
free_Ogre_DepthBuffer(Ogre::DepthBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DepthBuffer__setPoolId(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer *","_setPoolId", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","_setPoolId", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->_setPoolId(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_getPoolId(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","getPoolId", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  result = (Ogre::uint16)((Ogre::DepthBuffer const *)arg1)->getPoolId();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_getBitDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","getBitDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  result = (Ogre::uint16)((Ogre::DepthBuffer const *)arg1)->getBitDepth();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  result = (Ogre::uint32)((Ogre::DepthBuffer const *)arg1)->getWidth();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  result = (Ogre::uint32)((Ogre::DepthBuffer const *)arg1)->getHeight();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_getFsaa(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","getFsaa", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  result = (Ogre::uint32)((Ogre::DepthBuffer const *)arg1)->getFsaa();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_getFsaaHint(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","getFsaaHint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  result = (Ogre::String *) &((Ogre::DepthBuffer const *)arg1)->getFsaaHint();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_isManual(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","isManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  result = (bool)((Ogre::DepthBuffer const *)arg1)->isManual();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer_isCompatible(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer const *","isCompatible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","isCompatible", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  result = (bool)((Ogre::DepthBuffer const *)arg1)->isCompatible(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer__notifyRenderTargetAttached(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer *","_notifyRenderTargetAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_notifyRenderTargetAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  (arg1)->_notifyRenderTargetAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DepthBuffer__notifyRenderTargetDetached(int argc, VALUE *argv, VALUE self) {
  Ogre::DepthBuffer *arg1 = (Ogre::DepthBuffer *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 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_Ogre__DepthBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DepthBuffer *","_notifyRenderTargetDetached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DepthBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","_notifyRenderTargetDetached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  (arg1)->_notifyRenderTargetDetached(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassLodStrategy;

SWIGINTERN void
free_Ogre_LodStrategy(Ogre::LodStrategy *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LodStrategy_getBaseValue(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","getBaseValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->getBaseValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_transformBias(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","transformBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","transformBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->transformBias(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_transformUserValue(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","transformUserValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","transformUserValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->transformUserValue(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Real 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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject const *","getValue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getValue", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  result = (Ogre::Real)((Ogre::LodStrategy const *)arg1)->getValue((Ogre::MovableObject const *)arg2,(Ogre::Camera const *)arg3);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_getIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Mesh::MeshLodUsageList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::ushort 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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Mesh::MeshLodUsageList const &","getIndex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::MeshLodUsageList const &","getIndex", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Mesh::MeshLodUsageList * >(argp3);
  result = (Ogre::ushort)((Ogre::LodStrategy const *)arg1)->getIndex(arg2,(Ogre::Mesh::MeshLodUsageList const &)*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_getIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Material::LodValueList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::ushort 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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Material::LodValueList const &","getIndex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Material::LodValueList const &","getIndex", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Material::LodValueList * >(argp3);
  result = (Ogre::ushort)((Ogre::LodStrategy const *)arg1)->getIndex(arg2,(Ogre::Material::LodValueList const &)*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_LodStrategy_getIndex(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LodStrategy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LodStrategy_getIndex__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LodStrategy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_LodStrategy_getIndex__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "LodStrategy.getIndex", 
    "    Ogre::ushort LodStrategy.getIndex(Ogre::Real value, Ogre::Mesh::MeshLodUsageList const &meshLodUsageList)\n"
    "    Ogre::ushort LodStrategy.getIndex(Ogre::Real value, Ogre::Material::LodValueList const &materialLodValueList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_sort(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 0 ;
  Ogre::Mesh::MeshLodUsageList *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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","sort", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::MeshLodUsageList &","sort", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::MeshLodUsageList &","sort", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::MeshLodUsageList * >(argp2);
  ((Ogre::LodStrategy const *)arg1)->sort(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_isSorted(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 0 ;
  Ogre::Mesh::LodValueList *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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","isSorted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::LodValueList const &","isSorted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::LodValueList const &","isSorted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::LodValueList * >(argp2);
  result = (bool)((Ogre::LodStrategy const *)arg1)->isSorted((Ogre::Mesh::LodValueList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_assertSorted(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 0 ;
  Ogre::Mesh::LodValueList *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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","assertSorted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::LodValueList const &","assertSorted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::LodValueList const &","assertSorted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::LodValueList * >(argp2);
  ((Ogre::LodStrategy const *)arg1)->assertSorted((Ogre::Mesh::LodValueList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategy_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategy *arg1 = (Ogre::LodStrategy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategy const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategy * >(argp1);
  result = (Ogre::String *) &((Ogre::LodStrategy const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassDistanceLodStrategy;

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

SWIGINTERN VALUE
_wrap_new_DistanceLodStrategy(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DistanceLodStrategy";
  Ogre::DistanceLodStrategy *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DistanceLodStrategy *)new Ogre::DistanceLodStrategy();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_getBaseValue(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","getBaseValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  result = (Ogre::Real)((Ogre::DistanceLodStrategy const *)arg1)->getBaseValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_transformBias(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","transformBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","transformBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::DistanceLodStrategy const *)arg1)->transformBias(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_transformUserValue(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","transformUserValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","transformUserValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::DistanceLodStrategy const *)arg1)->transformUserValue(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_getIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Mesh::MeshLodUsageList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::ushort 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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Mesh::MeshLodUsageList const &","getIndex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::MeshLodUsageList const &","getIndex", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Mesh::MeshLodUsageList * >(argp3);
  result = (Ogre::ushort)((Ogre::DistanceLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Mesh::MeshLodUsageList const &)*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_getIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Material::LodValueList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::ushort 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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Material::LodValueList const &","getIndex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Material::LodValueList const &","getIndex", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Material::LodValueList * >(argp3);
  result = (Ogre::ushort)((Ogre::DistanceLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Material::LodValueList const &)*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DistanceLodStrategy_getIndex(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DistanceLodStrategy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DistanceLodStrategy_getIndex__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DistanceLodStrategy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_DistanceLodStrategy_getIndex__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "DistanceLodStrategy.getIndex", 
    "    Ogre::ushort DistanceLodStrategy.getIndex(Ogre::Real value, Ogre::Mesh::MeshLodUsageList const &meshLodUsageList)\n"
    "    Ogre::ushort DistanceLodStrategy.getIndex(Ogre::Real value, Ogre::Material::LodValueList const &materialLodValueList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_sort(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 0 ;
  Ogre::Mesh::MeshLodUsageList *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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","sort", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::MeshLodUsageList &","sort", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::MeshLodUsageList &","sort", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::MeshLodUsageList * >(argp2);
  ((Ogre::DistanceLodStrategy const *)arg1)->sort(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_isSorted(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 0 ;
  Ogre::Mesh::LodValueList *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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","isSorted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::LodValueList const &","isSorted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::LodValueList const &","isSorted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::LodValueList * >(argp2);
  result = (bool)((Ogre::DistanceLodStrategy const *)arg1)->isSorted((Ogre::Mesh::LodValueList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_setReferenceView(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Radian arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy *","setReferenceView", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setReferenceView", 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","setReferenceView", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Radian,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Radian","setReferenceView", 4, argv[2] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian","setReferenceView", 4, argv[2]));
    } else {
      arg4 = *(reinterpret_cast< Ogre::Radian * >(argp4));
    }
  }
  (arg1)->setReferenceView(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_setReferenceViewEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy *","setReferenceViewEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setReferenceViewEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setReferenceViewEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_getReferenceViewEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *arg1 = (Ogre::DistanceLodStrategy *) 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_Ogre__DistanceLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DistanceLodStrategy const *","getReferenceViewEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DistanceLodStrategy * >(argp1);
  result = (bool)((Ogre::DistanceLodStrategy const *)arg1)->getReferenceViewEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DistanceLodStrategy *) &Ogre::DistanceLodStrategy::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DistanceLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DistanceLodStrategy_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::DistanceLodStrategy *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DistanceLodStrategy *)Ogre::DistanceLodStrategy::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DistanceLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DistanceLodStrategy(Ogre::DistanceLodStrategy *arg1) {
    delete arg1;
}

swig_class SwigClassDualQuaternion;

SWIGINTERN VALUE
_wrap_new_DualQuaternion__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DualQuaternion";
  Ogre::DualQuaternion *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DualQuaternion__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  Ogre::Real arg8 ;
  float val1 ;
  int ecode1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DualQuaternion";
  Ogre::DualQuaternion *result = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",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","Ogre::DualQuaternion", 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","Ogre::DualQuaternion", 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","Ogre::DualQuaternion", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::DualQuaternion", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_float(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::DualQuaternion", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::DualQuaternion", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::DualQuaternion", 7, argv[6] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_float(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::DualQuaternion", 8, argv[7] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DualQuaternion__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Matrix4 *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DualQuaternion";
  Ogre::DualQuaternion *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__Matrix4,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","Ogre::DualQuaternion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","Ogre::DualQuaternion", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Matrix4 * >(argp1);
  result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion((Ogre::Matrix4 const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_DualQuaternion__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Quaternion *arg1 = 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DualQuaternion";
  Ogre::DualQuaternion *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__Quaternion,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","Ogre::DualQuaternion", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","Ogre::DualQuaternion", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Quaternion * >(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 &","Ogre::DualQuaternion", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::DualQuaternion", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion((Ogre::Quaternion const &)*arg1,(Ogre::Vector3 const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_DualQuaternion__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Real *arg1 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DualQuaternion";
  Ogre::DualQuaternion *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_float, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Real *","Ogre::DualQuaternion", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Real * >(argp1);
  result = (Ogre::DualQuaternion *)new Ogre::DualQuaternion(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_DualQuaternion(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs;
  if (argc > 8) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 0) {
    return _wrap_new_DualQuaternion__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DualQuaternion__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_float, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_DualQuaternion__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Quaternion, 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_DualQuaternion__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 8) {
    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_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_DualQuaternion__SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "DualQuaternion.new", 
    "    DualQuaternion.new()\n"
    "    DualQuaternion.new(Ogre::Real fW, Ogre::Real fX, Ogre::Real fY, Ogre::Real fZ, Ogre::Real fdW, Ogre::Real fdX, Ogre::Real fdY, Ogre::Real fdZ)\n"
    "    DualQuaternion.new(Ogre::Matrix4 const &rot)\n"
    "    DualQuaternion.new(Ogre::Quaternion const &q, Ogre::Vector3 const &trans)\n"
    "    DualQuaternion.new(Ogre::Real *valptr)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::DualQuaternion.==

  call-seq:
    ==(rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_DualQuaternion___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::DualQuaternion *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__DualQuaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DualQuaternion const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DualQuaternion const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DualQuaternion * >(argp2);
  result = (bool)((Ogre::DualQuaternion const *)arg1)->operator ==((Ogre::DualQuaternion const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_ptr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real *)(arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_ptr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Real *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion const *","ptr", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real *)((Ogre::DualQuaternion const *)arg1)->ptr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DualQuaternion_ptr(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_Ogre__DualQuaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DualQuaternion_ptr__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DualQuaternion, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_DualQuaternion_ptr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "DualQuaternion.ptr", 
    "    Ogre::Real const * DualQuaternion.ptr()\n"
    "    Ogre::Real const * DualQuaternion.ptr()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_swap(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::DualQuaternion *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","swap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__DualQuaternion,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DualQuaternion &","swap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DualQuaternion &","swap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DualQuaternion * >(argp2);
  (arg1)->swap(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_isNaN(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion const *","isNaN", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (bool)((Ogre::DualQuaternion const *)arg1)->isNaN();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_fromRotationTranslation(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Quaternion *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","fromRotationTranslation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(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 &","fromRotationTranslation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","fromRotationTranslation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(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 &","fromRotationTranslation", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","fromRotationTranslation", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->fromRotationTranslation((Ogre::Quaternion const &)*arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_toRotationTranslation(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  Ogre::Vector3 *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion const *","toRotationTranslation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(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 &","toRotationTranslation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion &","toRotationTranslation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(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 &","toRotationTranslation", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","toRotationTranslation", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ((Ogre::DualQuaternion const *)arg1)->toRotationTranslation(*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_fromTransformationMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Matrix4 *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","fromTransformationMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(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 &","fromTransformationMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","fromTransformationMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->fromTransformationMatrix((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_toTransformationMatrix(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Matrix4 *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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion const *","toTransformationMatrix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(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 &","toTransformationMatrix", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 &","toTransformationMatrix", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::DualQuaternion const *)arg1)->toTransformationMatrix(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_w_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","w", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","w", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->w = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_w_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","w", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->w);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_x_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","x", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->x = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_x_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","x", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->x);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_y_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","y", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->y = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_y_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","y", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->y);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_z_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","z", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->z = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_z_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","z", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->z);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dw_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","dw", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->dw = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dw_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->dw);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dx_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","dx", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->dx = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dx_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dx", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->dx);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dy_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","dy", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->dy = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dy_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->dy);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dz_set(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dz", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","dz", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->dz = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DualQuaternion_dz_get(int argc, VALUE *argv, VALUE self) {
  Ogre::DualQuaternion *arg1 = (Ogre::DualQuaternion *) 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_Ogre__DualQuaternion, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DualQuaternion *","dz", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DualQuaternion * >(argp1);
  result = (Ogre::Real) ((arg1)->dz);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DualQuaternion(Ogre::DualQuaternion *arg1) {
    delete arg1;
}

swig_class SwigClassDynLib;

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

SWIGINTERN VALUE
_wrap_new_DynLib(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::DynLib";
  Ogre::DynLib *result = 0 ;
  
  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 &","Ogre::DynLib", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::DynLib", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::DynLib *)new Ogre::DynLib((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_DynLib(Ogre::DynLib *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DynLib_load(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLib *arg1 = (Ogre::DynLib *) 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_Ogre__DynLib, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DynLib *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DynLib * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DynLib_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLib *arg1 = (Ogre::DynLib *) 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_Ogre__DynLib, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DynLib *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DynLib * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DynLib_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLib *arg1 = (Ogre::DynLib *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__DynLib, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DynLib const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DynLib * >(argp1);
  result = (Ogre::String *) &((Ogre::DynLib const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DynLib_getSymbol(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLib *arg1 = (Ogre::DynLib *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *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_Ogre__DynLib, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DynLib const *","getSymbol", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DynLib * >(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( "", "Ogre::String const &","getSymbol", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSymbol", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (void *)((Ogre::DynLib const *)arg1)->getSymbol((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassDynLibManager;

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

SWIGINTERN VALUE
_wrap_new_DynLibManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DynLibManager";
  Ogre::DynLibManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DynLibManager *)new Ogre::DynLibManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DynLibManager(Ogre::DynLibManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DynLibManager_load(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLibManager *arg1 = (Ogre::DynLibManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::DynLib *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_Ogre__DynLibManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DynLibManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DynLibManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::DynLib *)(arg1)->load((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DynLib, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DynLibManager_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLibManager *arg1 = (Ogre::DynLibManager *) 0 ;
  Ogre::DynLib *arg2 = (Ogre::DynLib *) 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_Ogre__DynLibManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DynLibManager *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DynLibManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__DynLib, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DynLib *","unload", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::DynLib * >(argp2);
  (arg1)->unload(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DynLibManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLibManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DynLibManager *) &Ogre::DynLibManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DynLibManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DynLibManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::DynLibManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DynLibManager *)Ogre::DynLibManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__DynLibManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassEdgeData;

SWIGINTERN VALUE
_wrap_EdgeData_triangles_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  Ogre::EdgeData::TriangleList *arg2 = (Ogre::EdgeData::TriangleList *) 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","triangles", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EdgeData::TriangleList *","triangles", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::EdgeData::TriangleList * >(argp2);
  if (arg1) (arg1)->triangles = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_triangles_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData::TriangleList *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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","triangles", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  result = (Ogre::EdgeData::TriangleList *)& ((arg1)->triangles);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_triangleFaceNormals_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  Ogre::EdgeData::TriangleFaceNormalList *arg2 = (Ogre::EdgeData::TriangleFaceNormalList *) 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","triangleFaceNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EdgeData::TriangleFaceNormalList *","triangleFaceNormals", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::EdgeData::TriangleFaceNormalList * >(argp2);
  if (arg1) (arg1)->triangleFaceNormals = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_triangleFaceNormals_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData::TriangleFaceNormalList *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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","triangleFaceNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  result = (Ogre::EdgeData::TriangleFaceNormalList *)& ((arg1)->triangleFaceNormals);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_triangleLightFacings_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  Ogre::EdgeData::TriangleLightFacingList *arg2 = (Ogre::EdgeData::TriangleLightFacingList *) 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","triangleLightFacings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EdgeData::TriangleLightFacingList *","triangleLightFacings", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::EdgeData::TriangleLightFacingList * >(argp2);
  if (arg1) (arg1)->triangleLightFacings = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_triangleLightFacings_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData::TriangleLightFacingList *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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","triangleLightFacings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  result = (Ogre::EdgeData::TriangleLightFacingList *)& ((arg1)->triangleLightFacings);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_edgeGroups_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  Ogre::EdgeData::EdgeGroupList *arg2 = (Ogre::EdgeData::EdgeGroupList *) 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","edgeGroups", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EdgeData::EdgeGroupList *","edgeGroups", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::EdgeData::EdgeGroupList * >(argp2);
  if (arg1) (arg1)->edgeGroups = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_edgeGroups_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData::EdgeGroupList *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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","edgeGroups", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  result = (Ogre::EdgeData::EdgeGroupList *)& ((arg1)->edgeGroups);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_isClosed_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","isClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isClosed", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isClosed = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_isClosed_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","isClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  result = (bool) ((arg1)->isClosed);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_updateTriangleLightFacing(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  Ogre::Vector4 *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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","updateTriangleLightFacing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","updateTriangleLightFacing", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","updateTriangleLightFacing", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  (arg1)->updateTriangleLightFacing((Ogre::Vector4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_updateFaceNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  size_t arg2 ;
  Ogre::HardwareVertexBufferSharedPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","updateFaceNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","updateFaceNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr const &","updateFaceNormals", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr const &","updateFaceNormals", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp3);
  (arg1)->updateFaceNormals(arg2,(Ogre::HardwareVertexBufferSharedPtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeData_log(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeData *arg1 = (Ogre::EdgeData *) 0 ;
  Ogre::Log *arg2 = (Ogre::Log *) 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_Ogre__EdgeData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeData *","log", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Log *","log", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Log * >(argp2);
  (arg1)->log(arg2);
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_EdgeData(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::EdgeData";
  Ogre::EdgeData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EdgeData *)new Ogre::EdgeData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EdgeData(Ogre::EdgeData *arg1) {
    delete arg1;
}

swig_class SwigClassEdgeListBuilder;

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

SWIGINTERN VALUE
_wrap_new_EdgeListBuilder(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::EdgeListBuilder";
  Ogre::EdgeListBuilder *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EdgeListBuilder *)new Ogre::EdgeListBuilder();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EdgeListBuilder(Ogre::EdgeListBuilder *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_EdgeListBuilder_addVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeListBuilder *arg1 = (Ogre::EdgeListBuilder *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__EdgeListBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeListBuilder *","addVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeListBuilder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData const *","addVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  (arg1)->addVertexData((Ogre::VertexData const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeListBuilder_addIndexData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeListBuilder *arg1 = (Ogre::EdgeListBuilder *) 0 ;
  Ogre::IndexData *arg2 = (Ogre::IndexData *) 0 ;
  size_t arg3 ;
  Ogre::RenderOperation::OperationType arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__EdgeListBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeListBuilder *","addIndexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeListBuilder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IndexData const *","addIndexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IndexData * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","addIndexData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::RenderOperation::OperationType","addIndexData", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::RenderOperation::OperationType >(val4);
  (arg1)->addIndexData((Ogre::IndexData const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeListBuilder_addIndexData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeListBuilder *arg1 = (Ogre::EdgeListBuilder *) 0 ;
  Ogre::IndexData *arg2 = (Ogre::IndexData *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__EdgeListBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeListBuilder *","addIndexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeListBuilder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IndexData const *","addIndexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IndexData * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","addIndexData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->addIndexData((Ogre::IndexData const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeListBuilder_addIndexData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeListBuilder *arg1 = (Ogre::EdgeListBuilder *) 0 ;
  Ogre::IndexData *arg2 = (Ogre::IndexData *) 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_Ogre__EdgeListBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeListBuilder *","addIndexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeListBuilder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IndexData const *","addIndexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IndexData * >(argp2);
  (arg1)->addIndexData((Ogre::IndexData const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_EdgeListBuilder_addIndexData(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_Ogre__EdgeListBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__IndexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_EdgeListBuilder_addIndexData__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__EdgeListBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__IndexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_EdgeListBuilder_addIndexData__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__EdgeListBuilder, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__IndexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(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_EdgeListBuilder_addIndexData__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "EdgeListBuilder.addIndexData", 
    "    void EdgeListBuilder.addIndexData(Ogre::IndexData const *indexData, size_t vertexSet, Ogre::RenderOperation::OperationType opType)\n"
    "    void EdgeListBuilder.addIndexData(Ogre::IndexData const *indexData, size_t vertexSet)\n"
    "    void EdgeListBuilder.addIndexData(Ogre::IndexData const *indexData)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeListBuilder_build(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeListBuilder *arg1 = (Ogre::EdgeListBuilder *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__EdgeListBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeListBuilder *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeListBuilder * >(argp1);
  result = (Ogre::EdgeData *)(arg1)->build();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EdgeListBuilder_log(int argc, VALUE *argv, VALUE self) {
  Ogre::EdgeListBuilder *arg1 = (Ogre::EdgeListBuilder *) 0 ;
  Ogre::Log *arg2 = (Ogre::Log *) 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_Ogre__EdgeListBuilder, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EdgeListBuilder *","log", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EdgeListBuilder * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Log, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Log *","log", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Log * >(argp2);
  (arg1)->log(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassEntity;

SWIGINTERN void
free_Ogre_Entity(Ogre::Entity *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Entity_getMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::MeshPtr *) &((Ogre::Entity const *)arg1)->getMesh();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getSubEntity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::SubEntity *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getSubEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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","getSubEntity", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Ogre::SubEntity *)((Ogre::Entity const *)arg1)->getSubEntity(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubEntity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getSubEntity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SubEntity *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getSubEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","getSubEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSubEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SubEntity *)((Ogre::Entity const *)arg1)->getSubEntity((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubEntity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_getSubEntity(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Entity_getSubEntity__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 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_Entity_getSubEntity__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.getSubEntity", 
    "    Ogre::SubEntity * Entity.getSubEntity(unsigned int index)\n"
    "    Ogre::SubEntity * Entity.getSubEntity(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getNumSubEntities(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getNumSubEntities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (unsigned int)((Ogre::Entity const *)arg1)->getNumSubEntities();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Entity.clone

  call-seq:
    clone(newName) -> Entity

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_Entity_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Entity *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","clone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","clone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Entity *)((Ogre::Entity const *)arg1)->clone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMaterialName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMaterialName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_setMaterialName(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_Ogre__Entity, 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_Entity_setMaterialName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 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_Entity_setMaterialName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Entity.setMaterialName", 
    "    void Entity.setMaterialName(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void Entity.setMaterialName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::MaterialPtr *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setRenderQueueGroupAndPriority(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setRenderQueueGroupAndPriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroupAndPriority", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setRenderQueueGroupAndPriority", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::Entity const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getChildObjectsBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getChildObjectsBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = ((Ogre::Entity const *)arg1)->getChildObjectsBoundingBox();
  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_Entity__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::String *) &((Ogre::Entity const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::AnimationState *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","getAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::AnimationState *)((Ogre::Entity const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_hasAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","hasAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","hasAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::Entity const *)arg1)->hasAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getAllAnimationStates(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimationStateSet *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getAllAnimationStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::AnimationStateSet *)((Ogre::Entity const *)arg1)->getAllAnimationStates();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setDisplaySkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setDisplaySkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDisplaySkeleton", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDisplaySkeleton(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getDisplaySkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getDisplaySkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->getDisplaySkeleton();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getManualLodLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Entity *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getManualLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getManualLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Entity *)((Ogre::Entity const *)arg1)->getManualLodLevel(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getNumManualLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getNumManualLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = ((Ogre::Entity const *)arg1)->getNumManualLodLevels();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getCurrentLodIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","getCurrentLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::ushort)(arg1)->getCurrentLodIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMeshLodBias__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Real arg2 ;
  Ogre::ushort arg3 ;
  Ogre::ushort arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMeshLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMeshLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setMeshLodBias", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::ushort","setMeshLodBias", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::ushort >(val4);
  (arg1)->setMeshLodBias(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMeshLodBias__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Real arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMeshLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMeshLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setMeshLodBias", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setMeshLodBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMeshLodBias__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMeshLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMeshLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMeshLodBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_setMeshLodBias(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Entity_setMeshLodBias__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Entity_setMeshLodBias__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Entity_setMeshLodBias__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Entity.setMeshLodBias", 
    "    void Entity.setMeshLodBias(Ogre::Real factor, Ogre::ushort maxDetailIndex, Ogre::ushort minDetailIndex)\n"
    "    void Entity.setMeshLodBias(Ogre::Real factor, Ogre::ushort maxDetailIndex)\n"
    "    void Entity.setMeshLodBias(Ogre::Real factor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMaterialLodBias__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Real arg2 ;
  Ogre::ushort arg3 ;
  Ogre::ushort arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMaterialLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaterialLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setMaterialLodBias", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::ushort","setMaterialLodBias", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::ushort >(val4);
  (arg1)->setMaterialLodBias(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMaterialLodBias__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Real arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMaterialLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaterialLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setMaterialLodBias", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setMaterialLodBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setMaterialLodBias__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setMaterialLodBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaterialLodBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaterialLodBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_setMaterialLodBias(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Entity_setMaterialLodBias__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Entity_setMaterialLodBias__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Entity_setMaterialLodBias__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Entity.setMaterialLodBias", 
    "    void Entity.setMaterialLodBias(Ogre::Real factor, Ogre::ushort maxDetailIndex, Ogre::ushort minDetailIndex)\n"
    "    void Entity.setMaterialLodBias(Ogre::Real factor, Ogre::ushort maxDetailIndex)\n"
    "    void Entity.setMaterialLodBias(Ogre::Real factor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setPolygonModeOverrideable(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setPolygonModeOverrideable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPolygonModeOverrideable", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPolygonModeOverrideable(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_attachObjectToBone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::MovableObject *arg3 = (Ogre::MovableObject *) 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  Ogre::TagPoint *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","attachObjectToBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","attachObjectToBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","attachObjectToBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MovableObject *","attachObjectToBone", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::MovableObject * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","attachObjectToBone", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","attachObjectToBone", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","attachObjectToBone", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","attachObjectToBone", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  result = (Ogre::TagPoint *)(arg1)->attachObjectToBone((Ogre::String const &)*arg2,arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Vector3 const &)*arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_attachObjectToBone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::MovableObject *arg3 = (Ogre::MovableObject *) 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::TagPoint *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","attachObjectToBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","attachObjectToBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","attachObjectToBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MovableObject *","attachObjectToBone", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::MovableObject * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","attachObjectToBone", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","attachObjectToBone", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  result = (Ogre::TagPoint *)(arg1)->attachObjectToBone((Ogre::String const &)*arg2,arg3,(Ogre::Quaternion const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_attachObjectToBone__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::MovableObject *arg3 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::TagPoint *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","attachObjectToBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","attachObjectToBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","attachObjectToBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MovableObject *","attachObjectToBone", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::MovableObject * >(argp3);
  result = (Ogre::TagPoint *)(arg1)->attachObjectToBone((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_attachObjectToBone(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Entity_attachObjectToBone__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Entity_attachObjectToBone__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Entity_attachObjectToBone__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Entity.attachObjectToBone", 
    "    Ogre::TagPoint * Entity.attachObjectToBone(Ogre::String const &boneName, Ogre::MovableObject *pMovable, Ogre::Quaternion const &offsetOrientation, Ogre::Vector3 const &offsetPosition)\n"
    "    Ogre::TagPoint * Entity.attachObjectToBone(Ogre::String const &boneName, Ogre::MovableObject *pMovable, Ogre::Quaternion const &offsetOrientation)\n"
    "    Ogre::TagPoint * Entity.attachObjectToBone(Ogre::String const &boneName, Ogre::MovableObject *pMovable)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_detachObjectFromBone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","detachObjectFromBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(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( "", "Ogre::String const &","detachObjectFromBone", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","detachObjectFromBone", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::MovableObject *)(arg1)->detachObjectFromBone((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_detachObjectFromBone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","detachObjectFromBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","detachObjectFromBone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->detachObjectFromBone(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_detachObjectFromBone(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Entity_detachObjectFromBone__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 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_Entity_detachObjectFromBone__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.detachObjectFromBone", 
    "    void Entity.detachObjectFromBone(Ogre::String const &movableName)\n"
    "    void Entity.detachObjectFromBone(Ogre::MovableObject *obj)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_detachAllObjectsFromBone(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","detachAllObjectsFromBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  (arg1)->detachAllObjectsFromBone();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getAttachedObjectIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::MovableObject *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::MovableObject * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","getAttachedObjectIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (arg1)->getAttachedObjectIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Entity::ChildObjectListIterator(static_cast< const Ogre::Entity::ChildObjectListIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::Real)((Ogre::Entity const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getWorldBoundingBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getWorldBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getWorldBoundingBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::AxisAlignedBox *) &((Ogre::Entity const *)arg1)->getWorldBoundingBox(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getWorldBoundingBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getWorldBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::Entity const *)arg1)->getWorldBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_getWorldBoundingBox(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Entity_getWorldBoundingBox__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Entity_getWorldBoundingBox__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.getWorldBoundingBox", 
    "    Ogre::AxisAlignedBox const & Entity.getWorldBoundingBox(bool derive)\n"
    "    Ogre::AxisAlignedBox const & Entity.getWorldBoundingBox()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getWorldBoundingSphere__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Sphere *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getWorldBoundingSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getWorldBoundingSphere", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Sphere *) &((Ogre::Entity const *)arg1)->getWorldBoundingSphere(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getWorldBoundingSphere__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Sphere *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getWorldBoundingSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::Sphere *) &((Ogre::Entity const *)arg1)->getWorldBoundingSphere();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_getWorldBoundingSphere(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Entity_getWorldBoundingSphere__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Entity_getWorldBoundingSphere__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity.getWorldBoundingSphere", 
    "    Ogre::Sphere const & Entity.getWorldBoundingSphere(bool derive)\n"
    "    Ogre::Sphere const & Entity.getWorldBoundingSphere()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::EdgeData *)(arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_hasEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","hasEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)(arg1)->hasEdgeList();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getShadowVolumeRenderableIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  unsigned long arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "unsigned long","getShadowVolumeRenderableIterator", 7, argv[5] ));
  } 
  arg7 = static_cast< unsigned long >(val7);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getShadowVolumeRenderableIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_getShadowVolumeRenderableIterator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Entity_getShadowVolumeRenderableIterator__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Entity_getShadowVolumeRenderableIterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Entity.getShadowVolumeRenderableIterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator Entity.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator Entity.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDistance)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getBoneMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_getBoneMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::Matrix4 *)((Ogre::Entity const *)arg1)->_getBoneMatrices();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getNumBoneMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_getNumBoneMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (unsigned short)((Ogre::Entity const *)arg1)->_getNumBoneMatrices();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_hasSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","hasSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->hasSkeleton();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonInstance *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::SkeletonInstance *)((Ogre::Entity const *)arg1)->getSkeleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_isHardwareAnimationEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","isHardwareAnimationEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)(arg1)->isHardwareAnimationEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__notifyAttached__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAttached", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAttached(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__notifyAttached__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity__notifyAttached(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Entity__notifyAttached__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Entity__notifyAttached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Entity._notifyAttached", 
    "    void Entity._notifyAttached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void Entity._notifyAttached(Ogre::Node *parent)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getSoftwareAnimationRequests(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getSoftwareAnimationRequests", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (int)((Ogre::Entity const *)arg1)->getSoftwareAnimationRequests();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getSoftwareAnimationNormalsRequests(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getSoftwareAnimationNormalsRequests", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (int)((Ogre::Entity const *)arg1)->getSoftwareAnimationNormalsRequests();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_addSoftwareAnimationRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","addSoftwareAnimationRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","addSoftwareAnimationRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->addSoftwareAnimationRequest(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_removeSoftwareAnimationRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","removeSoftwareAnimationRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","removeSoftwareAnimationRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->removeSoftwareAnimationRequest(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_shareSkeletonInstanceWith(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","shareSkeletonInstanceWith", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","shareSkeletonInstanceWith", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(argp2);
  (arg1)->shareSkeletonInstanceWith(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_hasVertexAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","hasVertexAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->hasVertexAnimation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_stopSharingSkeletonInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","stopSharingSkeletonInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  (arg1)->stopSharingSkeletonInstance();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_sharesSkeletonInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","sharesSkeletonInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->sharesSkeletonInstance();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getSkeletonInstanceSharingSet(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Entity::EntitySet *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getSkeletonInstanceSharingSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::Entity::EntitySet *)((Ogre::Entity const *)arg1)->getSkeletonInstanceSharingSet();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_refreshAvailableAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","refreshAvailableAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  (arg1)->refreshAvailableAnimationState();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__updateAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_updateAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  (arg1)->_updateAnimation();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__isAnimated(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_isAnimated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->_isAnimated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__isSkeletonAnimated(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_isSkeletonAnimated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->_isSkeletonAnimated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getSkelAnimVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_getSkelAnimVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::VertexData *)((Ogre::Entity const *)arg1)->_getSkelAnimVertexData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getSoftwareVertexAnimVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_getSoftwareVertexAnimVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::VertexData *)((Ogre::Entity const *)arg1)->_getSoftwareVertexAnimVertexData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getHardwareVertexAnimVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_getHardwareVertexAnimVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::VertexData *)((Ogre::Entity const *)arg1)->_getHardwareVertexAnimVertexData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getSkelAnimTempBufferInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TempBlendedBufferInfo *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_getSkelAnimTempBufferInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getSkelAnimTempBufferInfo();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getVertexAnimTempBufferInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TempBlendedBufferInfo *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_getVertexAnimTempBufferInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getVertexAnimTempBufferInfo();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::uint32)((Ogre::Entity const *)arg1)->getTypeFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getVertexDataForBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","getVertexDataForBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::VertexData *)(arg1)->getVertexDataForBinding();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_chooseVertexDataForBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::Entity::VertexDataBindChoice 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","chooseVertexDataForBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","chooseVertexDataForBinding", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::Entity::VertexDataBindChoice)(arg1)->chooseVertexDataForBinding(arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getBuffersMarkedForAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_getBuffersMarkedForAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->_getBuffersMarkedForAnimation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__markBuffersUsedForAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_markBuffersUsedForAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  (arg1)->_markBuffersUsedForAnimation();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_isInitialised(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","isInitialised", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->isInitialised();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__initialise__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_initialise", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_initialise(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__initialise__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  (arg1)->_initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity__initialise(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Entity__initialise__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Entity__initialise__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Entity._initialise", 
    "    void Entity._initialise(bool forceReinitialise)\n"
    "    void Entity._initialise()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__deinitialise(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","_deinitialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  (arg1)->_deinitialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_backgroundLoadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","backgroundLoadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","backgroundLoadingComplete", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->backgroundLoadingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Entity_visitRenderables(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_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Entity_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Entity_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Entity.visitRenderables", 
    "    void Entity.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void Entity.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity__getMeshLodFactorTransformed(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","_getMeshLodFactorTransformed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (Ogre::Real)((Ogre::Entity const *)arg1)->_getMeshLodFactorTransformed();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setSkipAnimationStateUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setSkipAnimationStateUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkipAnimationStateUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSkipAnimationStateUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getSkipAnimationStateUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getSkipAnimationStateUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->getSkipAnimationStateUpdate();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_setAlwaysUpdateMainSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity *","setAlwaysUpdateMainSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAlwaysUpdateMainSkeleton", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAlwaysUpdateMainSkeleton(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Entity_getAlwaysUpdateMainSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Entity *arg1 = (Ogre::Entity *) 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_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Entity const *","getAlwaysUpdateMainSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Entity * >(argp1);
  result = (bool)((Ogre::Entity const *)arg1)->getAlwaysUpdateMainSkeleton();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassEntityFactory;

SWIGINTERN void
free_Ogre_EntityFactory(Ogre::EntityFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_EntityFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::EntityFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_EntityFactory_FACTORY_TYPE_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::EntityFactory::FACTORY_TYPE_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::EntityFactory::FACTORY_TYPE_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityFactory *arg1 = (Ogre::EntityFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__EntityFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::EntityFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityFactory *arg1 = (Ogre::EntityFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__EntityFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassExternalTextureSource;

SWIGINTERN void
free_Ogre_ExternalTextureSource(Ogre::ExternalTextureSource *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ExternalTextureSource_setInputName(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  Ogre::String arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","setInputName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "Ogre::String","setInputName", 2, argv[0] )); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->setInputName(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_getInputName(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource const *","getInputName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  result = (Ogre::String *) &((Ogre::ExternalTextureSource const *)arg1)->getInputName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_setFPS(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","setFPS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setFPS", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setFPS(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_getFPS(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource const *","getFPS", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  result = (int)((Ogre::ExternalTextureSource const *)arg1)->getFPS();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_setPlayMode(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  Ogre::eTexturePlayMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","setPlayMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::eTexturePlayMode","setPlayMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::eTexturePlayMode >(val2);
  (arg1)->setPlayMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_getPlayMode(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::eTexturePlayMode 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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource const *","getPlayMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  result = (Ogre::eTexturePlayMode)((Ogre::ExternalTextureSource const *)arg1)->getPlayMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_setTextureTecPassStateLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 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 ;
  
  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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","setTextureTecPassStateLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setTextureTecPassStateLevel", 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","setTextureTecPassStateLevel", 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","setTextureTecPassStateLevel", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->setTextureTecPassStateLevel(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_getTextureTecPassStateLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  int *arg2 = 0 ;
  int *arg3 = 0 ;
  int *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource const *","getTextureTecPassStateLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "int &","getTextureTecPassStateLevel", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getTextureTecPassStateLevel", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< int * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "int &","getTextureTecPassStateLevel", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getTextureTecPassStateLevel", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< int * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "int &","getTextureTecPassStateLevel", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getTextureTecPassStateLevel", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< int * >(argp4);
  ((Ogre::ExternalTextureSource const *)arg1)->getTextureTecPassStateLevel(*arg2,*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_addBaseParams(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","addBaseParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  (arg1)->addBaseParams();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_getPluginStringName(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource const *","getPluginStringName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  result = (Ogre::String *) &((Ogre::ExternalTextureSource const *)arg1)->getPluginStringName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_getDictionaryStringName(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource const *","getDictionaryStringName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  result = (Ogre::String *) &((Ogre::ExternalTextureSource const *)arg1)->getDictionaryStringName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  result = (bool)(arg1)->initialise();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_shutDown(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","shutDown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp1);
  (arg1)->shutDown();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_createDefinedTexture__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","createDefinedTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(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( "", "Ogre::String const &","createDefinedTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createDefinedTexture", 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 &","createDefinedTexture", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createDefinedTexture", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->createDefinedTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_createDefinedTexture__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  Ogre::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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","createDefinedTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(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( "", "Ogre::String const &","createDefinedTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createDefinedTexture", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->createDefinedTexture((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ExternalTextureSource_createDefinedTexture(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_Ogre__ExternalTextureSource, 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_ExternalTextureSource_createDefinedTexture__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExternalTextureSource, 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_ExternalTextureSource_createDefinedTexture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ExternalTextureSource.createDefinedTexture", 
    "    void ExternalTextureSource.createDefinedTexture(Ogre::String const &sMaterialName, Ogre::String const &groupName)\n"
    "    void ExternalTextureSource.createDefinedTexture(Ogre::String const &sMaterialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_destroyAdvancedTexture__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","destroyAdvancedTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(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( "", "Ogre::String const &","destroyAdvancedTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAdvancedTexture", 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 &","destroyAdvancedTexture", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAdvancedTexture", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSource_destroyAdvancedTexture__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSource *arg1 = (Ogre::ExternalTextureSource *) 0 ;
  Ogre::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_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","destroyAdvancedTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSource * >(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( "", "Ogre::String const &","destroyAdvancedTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAdvancedTexture", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ExternalTextureSource_destroyAdvancedTexture(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_Ogre__ExternalTextureSource, 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_ExternalTextureSource_destroyAdvancedTexture__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExternalTextureSource, 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_ExternalTextureSource_destroyAdvancedTexture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ExternalTextureSource.destroyAdvancedTexture", 
    "    void ExternalTextureSource.destroyAdvancedTexture(Ogre::String const &sTextureName, Ogre::String const &groupName)\n"
    "    void ExternalTextureSource.destroyAdvancedTexture(Ogre::String const &sTextureName)\n");
  
  return Qnil;
}


swig_class SwigClassExternalTextureSourceManager;

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

SWIGINTERN VALUE
_wrap_new_ExternalTextureSourceManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ExternalTextureSourceManager";
  Ogre::ExternalTextureSourceManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ExternalTextureSourceManager *)new Ogre::ExternalTextureSourceManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ExternalTextureSourceManager(Ogre::ExternalTextureSourceManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_setCurrentPlugIn(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *arg1 = (Ogre::ExternalTextureSourceManager *) 0 ;
  Ogre::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_Ogre__ExternalTextureSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSourceManager *","setCurrentPlugIn", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSourceManager * >(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( "", "Ogre::String const &","setCurrentPlugIn", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setCurrentPlugIn", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setCurrentPlugIn((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_getCurrentPlugIn(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *arg1 = (Ogre::ExternalTextureSourceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ExternalTextureSource *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_Ogre__ExternalTextureSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSourceManager const *","getCurrentPlugIn", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSourceManager * >(argp1);
  result = (Ogre::ExternalTextureSource *)((Ogre::ExternalTextureSourceManager const *)arg1)->getCurrentPlugIn();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSource, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_destroyAdvancedTexture__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *arg1 = (Ogre::ExternalTextureSourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ExternalTextureSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSourceManager *","destroyAdvancedTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSourceManager * >(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( "", "Ogre::String const &","destroyAdvancedTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAdvancedTexture", 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 &","destroyAdvancedTexture", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAdvancedTexture", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_destroyAdvancedTexture__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *arg1 = (Ogre::ExternalTextureSourceManager *) 0 ;
  Ogre::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_Ogre__ExternalTextureSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSourceManager *","destroyAdvancedTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSourceManager * >(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( "", "Ogre::String const &","destroyAdvancedTexture", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAdvancedTexture", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyAdvancedTexture((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ExternalTextureSourceManager_destroyAdvancedTexture(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_Ogre__ExternalTextureSourceManager, 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_ExternalTextureSourceManager_destroyAdvancedTexture__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ExternalTextureSourceManager, 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_ExternalTextureSourceManager_destroyAdvancedTexture__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ExternalTextureSourceManager.destroyAdvancedTexture", 
    "    void ExternalTextureSourceManager.destroyAdvancedTexture(Ogre::String const &sTextureName, Ogre::String const &groupName)\n"
    "    void ExternalTextureSourceManager.destroyAdvancedTexture(Ogre::String const &sTextureName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_getExternalTextureSource(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *arg1 = (Ogre::ExternalTextureSourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ExternalTextureSource *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_Ogre__ExternalTextureSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSourceManager *","getExternalTextureSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSourceManager * >(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( "", "Ogre::String const &","getExternalTextureSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getExternalTextureSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ExternalTextureSource *)(arg1)->getExternalTextureSource((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSource, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_setExternalTextureSource(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *arg1 = (Ogre::ExternalTextureSourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ExternalTextureSource *arg3 = (Ogre::ExternalTextureSource *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ExternalTextureSourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSourceManager *","setExternalTextureSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ExternalTextureSourceManager * >(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( "", "Ogre::String const &","setExternalTextureSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setExternalTextureSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ExternalTextureSource, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ExternalTextureSource *","setExternalTextureSource", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ExternalTextureSource * >(argp3);
  (arg1)->setExternalTextureSource((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ExternalTextureSourceManager *) &Ogre::ExternalTextureSourceManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ExternalTextureSourceManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ExternalTextureSourceManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ExternalTextureSourceManager *)Ogre::ExternalTextureSourceManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ExternalTextureSourceManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassFileSystemArchive;

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

SWIGINTERN VALUE
_wrap_new_FileSystemArchive(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::FileSystemArchive";
  Ogre::FileSystemArchive *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::FileSystemArchive", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileSystemArchive", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::FileSystemArchive", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FileSystemArchive", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::FileSystemArchive *)new Ogre::FileSystemArchive((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_FileSystemArchive(Ogre::FileSystemArchive *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FileSystemArchive_isCaseSensitive(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","isCaseSensitive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  result = (bool)((Ogre::FileSystemArchive const *)arg1)->isCaseSensitive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_load(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_open__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","open", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","open", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","open", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = ((Ogre::FileSystemArchive const *)arg1)->open((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_open__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","open", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","open", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::FileSystemArchive const *)arg1)->open((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_FileSystemArchive_open(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_Ogre__FileSystemArchive, 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_FileSystemArchive_open__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileSystemArchive_open__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FileSystemArchive.open", 
    "    Ogre::DataStreamPtr FileSystemArchive.open(Ogre::String const &filename, bool readOnly)\n"
    "    Ogre::DataStreamPtr FileSystemArchive.open(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_create(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::FileSystemArchive const *)arg1)->create((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_remove(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","remove", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","remove", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","remove", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ((Ogre::FileSystemArchive const *)arg1)->remove((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_list__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","list", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","list", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->list(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_list__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","list", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->list(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_list__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  result = (arg1)->list();
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FileSystemArchive_list(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_Ogre__FileSystemArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileSystemArchive_list__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FileSystemArchive_list__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileSystemArchive_list__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FileSystemArchive.list", 
    "    Ogre::StringVectorPtr FileSystemArchive.list(bool recursive, bool dirs)\n"
    "    Ogre::StringVectorPtr FileSystemArchive.list(bool recursive)\n"
    "    Ogre::StringVectorPtr FileSystemArchive.list()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_listFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","listFileInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","listFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->listFileInfo(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_listFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","listFileInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->listFileInfo(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_listFileInfo__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(argp1);
  result = (arg1)->listFileInfo();
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_FileSystemArchive_listFileInfo(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_Ogre__FileSystemArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_FileSystemArchive_listFileInfo__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_FileSystemArchive_listFileInfo__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileSystemArchive_listFileInfo__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "FileSystemArchive.listFileInfo", 
    "    Ogre::FileInfoListPtr FileSystemArchive.listFileInfo(bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.listFileInfo(bool recursive)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.listFileInfo()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::FileSystemArchive.find

  call-seq:
    find(pattern, recursive=true, dirs=false) -> StringVectorPtr
    find(pattern, recursive=true) -> StringVectorPtr
    find(pattern) -> StringVectorPtr

Find an element in the class.
*/
SWIGINTERN VALUE
_wrap_FileSystemArchive_find__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","find", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","find", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->find((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_find__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","find", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->find((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_find__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_FileSystemArchive_find(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_Ogre__FileSystemArchive, 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_FileSystemArchive_find__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileSystemArchive_find__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FileSystemArchive_find__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FileSystemArchive.find", 
    "    Ogre::StringVectorPtr FileSystemArchive.find(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::StringVectorPtr FileSystemArchive.find(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::StringVectorPtr FileSystemArchive.find(Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_findFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","findFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","findFileInfo", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = ((Ogre::FileSystemArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_findFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","findFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = ((Ogre::FileSystemArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_findFileInfo__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::FileSystemArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_FileSystemArchive_findFileInfo(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_Ogre__FileSystemArchive, 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_FileSystemArchive_findFileInfo__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_FileSystemArchive_findFileInfo__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FileSystemArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_FileSystemArchive_findFileInfo__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "FileSystemArchive.findFileInfo", 
    "    Ogre::FileInfoListPtr FileSystemArchive.findFileInfo(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.findFileInfo(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::FileInfoListPtr FileSystemArchive.findFileInfo(Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_exists(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","exists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","exists", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exists", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->exists((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_getModifiedTime(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchive *arg1 = (Ogre::FileSystemArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  time_t 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_Ogre__FileSystemArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchive *","getModifiedTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchive * >(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( "", "Ogre::String const &","getModifiedTime", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getModifiedTime", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getModifiedTime((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new time_t(static_cast< const time_t& >(result))), SWIGTYPE_p_time_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_setIgnoreHidden(int argc, VALUE *argv, VALUE self) {
  bool arg1 ;
  bool val1 ;
  int ecode1 = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_bool(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "bool","Ogre::FileSystemArchive::setIgnoreHidden", 1, argv[0] ));
  } 
  arg1 = static_cast< bool >(val1);
  Ogre::FileSystemArchive::setIgnoreHidden(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_getIgnoreHidden(int argc, VALUE *argv, VALUE self) {
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (bool)Ogre::FileSystemArchive::getIgnoreHidden();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_msIgnoreHidden_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_bool(static_cast< bool >(Ogre::FileSystemArchive::msIgnoreHidden));
  return _val;
}


SWIGINTERN VALUE
_wrap_FileSystemArchive_msIgnoreHidden_set(VALUE self, VALUE _val) {
  {
    bool val;
    int res = SWIG_AsVal_bool(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::FileSystemArchive::msIgnoreHidden""' of type '""bool""'");
    }
    Ogre::FileSystemArchive::msIgnoreHidden = static_cast< bool >(val);
  }
  return _val;
fail:
  return Qnil;
}


swig_class SwigClassFileSystemArchiveFactory;

SWIGINTERN void
free_Ogre_FileSystemArchiveFactory(Ogre::FileSystemArchiveFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FileSystemArchiveFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchiveFactory *arg1 = (Ogre::FileSystemArchiveFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__FileSystemArchiveFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchiveFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchiveFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::FileSystemArchiveFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchiveFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchiveFactory *arg1 = (Ogre::FileSystemArchiveFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Archive *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_Ogre__FileSystemArchiveFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchiveFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchiveFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Archive *)(arg1)->createInstance((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Archive, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FileSystemArchiveFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::FileSystemArchiveFactory *arg1 = (Ogre::FileSystemArchiveFactory *) 0 ;
  Ogre::Archive *arg2 = (Ogre::Archive *) 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_Ogre__FileSystemArchiveFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FileSystemArchiveFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FileSystemArchiveFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Archive, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Archive *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Archive * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_FileSystemArchiveFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::FileSystemArchiveFactory";
  Ogre::FileSystemArchiveFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FileSystemArchiveFactory *)new Ogre::FileSystemArchiveFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


swig_class SwigClassFont;

SWIGINTERN VALUE
_wrap_new_Font__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Font";
  Ogre::Font *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Font", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Font", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Font", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Font", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Font", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Font", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Font", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","Ogre::Font", 6, argv[5] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::Font *)new Ogre::Font(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Font__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Font";
  Ogre::Font *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Font", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Font", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Font", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Font", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Font", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Font", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::Font", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::Font *)new Ogre::Font(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Font__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Font";
  Ogre::Font *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::Font", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Font", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Font", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::Font", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Font", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Font", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::Font *)new Ogre::Font(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Font(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_Font__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_Font__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_Font__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Font.new", 
    "    Font.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Font.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual)\n"
    "    Font.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Font(Ogre::Font *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Font_setType(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::FontType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FontType","setType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FontType >(val2);
  (arg1)->setType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::FontType 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::FontType)((Ogre::Font const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_setSource(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(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( "", "Ogre::String const &","setSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSource((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getSource(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::String *) &((Ogre::Font const *)arg1)->getSource();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_setCharacterSpacer(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::uint 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setCharacterSpacer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint","setCharacterSpacer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint >(val2);
  (arg1)->setCharacterSpacer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getCharacterSpacer(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getCharacterSpacer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::uint)((Ogre::Font const *)arg1)->getCharacterSpacer();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_setTrueTypeSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setTrueTypeSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTrueTypeSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTrueTypeSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_setTrueTypeResolution(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::uint 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setTrueTypeResolution", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint","setTrueTypeResolution", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint >(val2);
  (arg1)->setTrueTypeResolution(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getTrueTypeSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getTrueTypeSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::Real)((Ogre::Font const *)arg1)->getTrueTypeSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getTrueTypeResolution(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getTrueTypeResolution", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::uint)((Ogre::Font const *)arg1)->getTrueTypeResolution();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getTrueTypeMaxBearingY(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getTrueTypeMaxBearingY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (int)((Ogre::Font const *)arg1)->getTrueTypeMaxBearingY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getGlyphTexCoords(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Font::CodePoint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Font::UVRect *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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getGlyphTexCoords", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Font::CodePoint","getGlyphTexCoords", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Font::CodePoint >(val2);
  result = (Ogre::Font::UVRect *) &((Ogre::Font const *)arg1)->getGlyphTexCoords(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_setGlyphTexCoords(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Font::CodePoint arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setGlyphTexCoords", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Font::CodePoint","setGlyphTexCoords", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Font::CodePoint >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setGlyphTexCoords", 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","setGlyphTexCoords", 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","setGlyphTexCoords", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setGlyphTexCoords", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setGlyphTexCoords", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setGlyphTexCoords(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getGlyphAspectRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Font::CodePoint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getGlyphAspectRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Font::CodePoint","getGlyphAspectRatio", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Font::CodePoint >(val2);
  result = (Ogre::Real)((Ogre::Font const *)arg1)->getGlyphAspectRatio(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_setGlyphAspectRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Font::CodePoint arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setGlyphAspectRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Font::CodePoint","setGlyphAspectRatio", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Font::CodePoint >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setGlyphAspectRatio", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setGlyphAspectRatio(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getGlyphInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Font::CodePoint arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Font::GlyphInfo *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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getGlyphInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Font::CodePoint","getGlyphInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Font::CodePoint >(val2);
  result = (Ogre::Font::GlyphInfo *) &((Ogre::Font const *)arg1)->getGlyphInfo(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Font__GlyphInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_addCodePointRange(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Font::CodePointRange *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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","addCodePointRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__pairT_unsigned_int_unsigned_int_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Font::CodePointRange const &","addCodePointRange", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Font::CodePointRange const &","addCodePointRange", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Font::CodePointRange * >(argp2);
  (arg1)->addCodePointRange((Ogre::Font::CodePointRange const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_clearCodePointRanges(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","clearCodePointRanges", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  (arg1)->clearCodePointRanges();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getCodePointRangeList(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Font::CodePointRangeList *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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getCodePointRangeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::Font::CodePointRangeList *) &((Ogre::Font const *)arg1)->getCodePointRangeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getMaterial__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::Font const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getMaterial__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::MaterialPtr *) &(arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Font_getMaterial(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_Ogre__Font, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Font_getMaterial__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Font, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Font_getMaterial__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Font.getMaterial", 
    "    Ogre::MaterialPtr const & Font.getMaterial()\n"
    "    Ogre::MaterialPtr const & Font.getMaterial()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_setAntialiasColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","setAntialiasColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAntialiasColour", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAntialiasColour(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_getAntialiasColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font const *","getAntialiasColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (bool)((Ogre::Font const *)arg1)->getAntialiasColour();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Font_loadResource(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","loadResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","loadResource", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->loadResource(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassFontPtr;

SWIGINTERN VALUE
_wrap_new_FontPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::FontPtr";
  Ogre::FontPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FontPtr *)new Ogre::FontPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FontPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Font *arg1 = (Ogre::Font *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FontPtr";
  Ogre::FontPtr *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__Font, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Font *","Ogre::FontPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Font * >(argp1);
  result = (Ogre::FontPtr *)new Ogre::FontPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_FontPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::FontPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FontPtr";
  Ogre::FontPtr *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__FontPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FontPtr const &","Ogre::FontPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FontPtr const &","Ogre::FontPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::FontPtr * >(argp1);
  result = (Ogre::FontPtr *)new Ogre::FontPtr((Ogre::FontPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_FontPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FontPtr";
  Ogre::FontPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::FontPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::FontPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::FontPtr *)new Ogre::FontPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_FontPtr(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_FontPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Font, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FontPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__FontPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FontPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_FontPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "FontPtr.new", 
    "    FontPtr.new()\n"
    "    FontPtr.new(Ogre::Font *rep)\n"
    "    FontPtr.new(Ogre::FontPtr const &r)\n"
    "    FontPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_FontPtr(Ogre::FontPtr *arg1) {
    delete arg1;
}

swig_class SwigClassFontManager;

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

SWIGINTERN VALUE
_wrap_new_FontManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::FontManager";
  Ogre::FontManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FontManager *)new Ogre::FontManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FontManager(Ogre::FontManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FontManager_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::FontManager *arg1 = (Ogre::FontManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__FontManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FontManager *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FontManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FontManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::FontManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FontManager *) &Ogre::FontManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__FontManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FontManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::FontManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FontManager *)Ogre::FontManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__FontManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassFreeImageCodec;

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

SWIGINTERN VALUE
_wrap_new_FreeImageCodec(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  unsigned int arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::FreeImageCodec";
  Ogre::FreeImageCodec *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::FreeImageCodec", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::FreeImageCodec", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned int","Ogre::FreeImageCodec", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Ogre::FreeImageCodec *)new Ogre::FreeImageCodec((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_FreeImageCodec(Ogre::FreeImageCodec *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FreeImageCodec_code(int argc, VALUE *argv, VALUE self) {
  Ogre::FreeImageCodec *arg1 = (Ogre::FreeImageCodec *) 0 ;
  Ogre::MemoryDataStreamPtr *arg2 = 0 ;
  Ogre::Codec::CodecDataPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__FreeImageCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FreeImageCodec const *","code", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FreeImageCodec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MemoryDataStreamPtr &","code", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MemoryDataStreamPtr &","code", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MemoryDataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__CodecData_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Codec::CodecDataPtr &","code", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Codec::CodecDataPtr &","code", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Codec::CodecDataPtr * >(argp3);
  result = ((Ogre::FreeImageCodec const *)arg1)->code(*arg2,*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FreeImageCodec_codeToFile(int argc, VALUE *argv, VALUE self) {
  Ogre::FreeImageCodec *arg1 = (Ogre::FreeImageCodec *) 0 ;
  Ogre::MemoryDataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Codec::CodecDataPtr *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__FreeImageCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FreeImageCodec const *","codeToFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FreeImageCodec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MemoryDataStreamPtr &","codeToFile", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MemoryDataStreamPtr &","codeToFile", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MemoryDataStreamPtr * >(argp2);
  {
    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 &","codeToFile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","codeToFile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__CodecData_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Codec::CodecDataPtr &","codeToFile", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Codec::CodecDataPtr &","codeToFile", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Codec::CodecDataPtr * >(argp4);
  ((Ogre::FreeImageCodec const *)arg1)->codeToFile(*arg2,(Ogre::String const &)*arg3,*arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FreeImageCodec_decode(int argc, VALUE *argv, VALUE self) {
  Ogre::FreeImageCodec *arg1 = (Ogre::FreeImageCodec *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::MemoryDataStream >,Ogre::SharedPtr< Ogre::Codec::CodecData > > > 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_Ogre__FreeImageCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FreeImageCodec const *","decode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FreeImageCodec * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","decode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","decode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = ((Ogre::FreeImageCodec const *)arg1)->decode(*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Codec::DecodeResult(static_cast< const Ogre::Codec::DecodeResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FreeImageCodec_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::FreeImageCodec *arg1 = (Ogre::FreeImageCodec *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__FreeImageCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FreeImageCodec const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FreeImageCodec * >(argp1);
  result = ((Ogre::FreeImageCodec const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FreeImageCodec_magicNumberToFileExt(int argc, VALUE *argv, VALUE self) {
  Ogre::FreeImageCodec *arg1 = (Ogre::FreeImageCodec *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_Ogre__FreeImageCodec, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FreeImageCodec const *","magicNumberToFileExt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FreeImageCodec * >(argp1);
  res2 = SWIG_AsCharPtrAndSize(argv[0], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","magicNumberToFileExt", 2, argv[0] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","magicNumberToFileExt", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = ((Ogre::FreeImageCodec const *)arg1)->magicNumberToFileExt((char const *)arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FreeImageCodec_startup(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::FreeImageCodec::startup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FreeImageCodec_shutdown(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::FreeImageCodec::shutdown();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassGpuProgramManager;

SWIGINTERN void
free_Ogre_GpuProgramManager(Ogre::GpuProgramManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_GpuProgramManager_load(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::GpuProgramType arg5 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  Ogre::GpuProgramPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","load", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::GpuProgramType >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","load", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramPtr(static_cast< const Ogre::GpuProgramPtr& >(result))), SWIGTYPE_p_Ogre__GpuProgramPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_loadFromString(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::GpuProgramType arg5 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  Ogre::GpuProgramPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","loadFromString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","loadFromString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromString", 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 &","loadFromString", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromString", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","loadFromString", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromString", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","loadFromString", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::GpuProgramType >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","loadFromString", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadFromString", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  result = (arg1)->loadFromString((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramPtr(static_cast< const Ogre::GpuProgramPtr& >(result))), SWIGTYPE_p_Ogre__GpuProgramPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getSupportedSyntax(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramManager::SyntaxCodes *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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","getSupportedSyntax", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  result = (Ogre::GpuProgramManager::SyntaxCodes *) &((Ogre::GpuProgramManager const *)arg1)->getSupportedSyntax();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_isSyntaxSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","isSyntaxSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","isSyntaxSupported", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isSyntaxSupported", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::GpuProgramManager const *)arg1)->isSyntaxSupported((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_createParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","createParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  result = (arg1)->createParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_createProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::GpuProgramType arg5 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  Ogre::GpuProgramPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","createProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","createProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgram", 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 &","createProgram", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgram", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createProgram", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgram", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","createProgram", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::GpuProgramType >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","createProgram", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgram", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  result = (arg1)->createProgram((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramPtr(static_cast< const Ogre::GpuProgramPtr& >(result))), SWIGTYPE_p_Ogre__GpuProgramPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_createProgramFromString(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::GpuProgramType arg5 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  Ogre::GpuProgramPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","createProgramFromString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","createProgramFromString", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgramFromString", 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 &","createProgramFromString", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgramFromString", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createProgramFromString", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgramFromString", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","createProgramFromString", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::GpuProgramType >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","createProgramFromString", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgramFromString", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  result = (arg1)->createProgramFromString((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramPtr(static_cast< const Ogre::GpuProgramPtr& >(result))), SWIGTYPE_p_Ogre__GpuProgramPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_create__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::GpuProgramType arg4 ;
  Ogre::String *arg5 = 0 ;
  bool arg6 ;
  Ogre::ManualResourceLoader *arg7 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Ogre::ResourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","create", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::GpuProgramType >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","create", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","create", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","create", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp7);
  result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_create__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::GpuProgramType arg4 ;
  Ogre::String *arg5 = 0 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::ResourcePtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","create", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::GpuProgramType >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","create", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","create", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_create__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::GpuProgramType arg4 ;
  Ogre::String *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  Ogre::ResourcePtr result;
  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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","create", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::GpuProgramType >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","create", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  result = (arg1)->create((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramManager_create(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramManager, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_GpuProgramManager_create__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramManager, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_GpuProgramManager_create__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramManager, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_GpuProgramManager_create__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "GpuProgramManager.create", 
    "    Ogre::ResourcePtr GpuProgramManager.create(Ogre::String const &name, Ogre::String const &group, Ogre::GpuProgramType gptype, Ogre::String const &syntaxCode, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourcePtr GpuProgramManager.create(Ogre::String const &name, Ogre::String const &group, Ogre::GpuProgramType gptype, Ogre::String const &syntaxCode, bool isManual)\n"
    "    Ogre::ResourcePtr GpuProgramManager.create(Ogre::String const &name, Ogre::String const &group, Ogre::GpuProgramType gptype, Ogre::String const &syntaxCode)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getByName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::ResourcePtr 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","getByName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","getByName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getByName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","getByName", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->getByName((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getByName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ResourcePtr 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","getByName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","getByName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getByName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getByName((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ResourcePtr(static_cast< const Ogre::ResourcePtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramManager_getByName(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_Ogre__GpuProgramManager, 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_GpuProgramManager_getByName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramManager_getByName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "GpuProgramManager.getByName", 
    "    Ogre::ResourcePtr GpuProgramManager.getByName(Ogre::String const &name, bool preferHighLevelPrograms)\n"
    "    Ogre::ResourcePtr GpuProgramManager.getByName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_createSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuSharedParameters > > 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","createSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","createSharedParameters", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSharedParameters", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->createSharedParameters((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::GpuSharedParametersPtr(static_cast< const Ogre::GpuSharedParametersPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuSharedParameters > > 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","getSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","getSharedParameters", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSharedParameters", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::GpuProgramManager const *)arg1)->getSharedParameters((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::GpuSharedParametersPtr(static_cast< const Ogre::GpuSharedParametersPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuSharedParameters_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getAvailableSharedParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramManager::SharedParametersMap *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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","getAvailableSharedParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  result = (Ogre::GpuProgramManager::SharedParametersMap *) &((Ogre::GpuProgramManager const *)arg1)->getAvailableSharedParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getSaveMicrocodesToCache(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","getSaveMicrocodesToCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  result = (bool)(arg1)->getSaveMicrocodesToCache();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_setSaveMicrocodesToCache(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","setSaveMicrocodesToCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSaveMicrocodesToCache", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSaveMicrocodesToCache(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_canGetCompiledShaderBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","canGetCompiledShaderBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  result = (bool)(arg1)->canGetCompiledShaderBuffer();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_isMicrocodeAvailableInCache(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","isMicrocodeAvailableInCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","isMicrocodeAvailableInCache", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isMicrocodeAvailableInCache", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::GpuProgramManager const *)arg1)->isMicrocodeAvailableInCache((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getMicrocodeFromCache(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::GpuProgramManager::Microcode *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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","getMicrocodeFromCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","getMicrocodeFromCache", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMicrocodeFromCache", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::GpuProgramManager::Microcode *) &((Ogre::GpuProgramManager const *)arg1)->getMicrocodeFromCache((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_createMicrocode(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::MemoryDataStream > > 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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","createMicrocode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createMicrocode", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = ((Ogre::GpuProgramManager const *)arg1)->createMicrocode(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramManager::Microcode(static_cast< const Ogre::GpuProgramManager::Microcode& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_addMicrocodeToCache(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::GpuProgramManager::Microcode *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","addMicrocodeToCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(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( "", "Ogre::String const &","addMicrocodeToCache", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addMicrocodeToCache", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager::Microcode const &","addMicrocodeToCache", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramManager::Microcode const &","addMicrocodeToCache", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::GpuProgramManager::Microcode * >(argp3);
  (arg1)->addMicrocodeToCache((Ogre::String const &)*arg2,(Ogre::GpuProgramManager::Microcode const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_saveMicrocodeCache(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg2 ;
  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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager const *","saveMicrocodeCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","saveMicrocodeCache", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","saveMicrocodeCache", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp2));
    }
  }
  ((Ogre::GpuProgramManager const *)arg1)->saveMicrocodeCache(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_loadMicrocodeCache(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *arg1 = (Ogre::GpuProgramManager *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg2 ;
  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_Ogre__GpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramManager *","loadMicrocodeCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramManager * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","loadMicrocodeCache", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","loadMicrocodeCache", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp2));
    }
  }
  (arg1)->loadMicrocodeCache(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuProgramManager *) &Ogre::GpuProgramManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuProgramManager *)Ogre::GpuProgramManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassGpuProgramUsage;

SWIGINTERN VALUE
_wrap_new_GpuProgramUsage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramType arg1 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuProgramUsage";
  Ogre::GpuProgramUsage *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( "", "Ogre::GpuProgramType","Ogre::GpuProgramUsage", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::GpuProgramType >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","Ogre::GpuProgramUsage", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  result = (Ogre::GpuProgramUsage *)new Ogre::GpuProgramUsage(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_GpuProgramUsage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::GpuProgramUsage";
  Ogre::GpuProgramUsage *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__GpuProgramUsage,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage const &","Ogre::GpuProgramUsage", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramUsage const &","Ogre::GpuProgramUsage", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","Ogre::GpuProgramUsage", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  result = (Ogre::GpuProgramUsage *)new Ogre::GpuProgramUsage((Ogre::GpuProgramUsage const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_GpuProgramUsage(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__GpuProgramUsage, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GpuProgramUsage__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_GpuProgramUsage__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "GpuProgramUsage.new", 
    "    GpuProgramUsage.new(Ogre::GpuProgramType gptype, Ogre::Pass *parent)\n"
    "    GpuProgramUsage.new(Ogre::GpuProgramUsage const &rhs, Ogre::Pass *newparent)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuProgramUsage(Ogre::GpuProgramUsage *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_GpuProgramUsage_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramType 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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  result = (Ogre::GpuProgramType)((Ogre::GpuProgramUsage const *)arg1)->getType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_setProgramName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","setProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(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( "", "Ogre::String const &","setProgramName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setProgramName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setProgramName", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setProgramName((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_setProgramName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  Ogre::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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","setProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(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( "", "Ogre::String const &","setProgramName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setProgramName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setProgramName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_GpuProgramUsage_setProgramName(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_Ogre__GpuProgramUsage, 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_GpuProgramUsage_setProgramName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__GpuProgramUsage, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_GpuProgramUsage_setProgramName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "GpuProgramUsage.setProgramName", 
    "    void GpuProgramUsage.setProgramName(Ogre::String const &name, bool resetParams)\n"
    "    void GpuProgramUsage.setProgramName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_setProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  Ogre::GpuProgramPtr *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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","setProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__GpuProgramPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramPtr &","setProgram", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramPtr &","setProgram", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramPtr * >(argp2);
  (arg1)->setProgram(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_getProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage const *","getProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::GpuProgramUsage const *)arg1)->getProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_getProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage const *","getProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  result = (Ogre::String *) &((Ogre::GpuProgramUsage const *)arg1)->getProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_setParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","setParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_getParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","getParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  result = (arg1)->getParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage__load(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","_load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  (arg1)->_load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage__unload(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","_unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  (arg1)->_unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_unloadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","unloadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","unloadingComplete", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->unloadingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramUsage_loadingComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramUsage *arg1 = (Ogre::GpuProgramUsage *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__GpuProgramUsage, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramUsage *","loadingComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramUsage * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","loadingComplete", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->loadingComplete(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassHardwareOcclusionQuery;

SWIGINTERN void
free_Ogre_HardwareOcclusionQuery(Ogre::HardwareOcclusionQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_beginOcclusionQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareOcclusionQuery *arg1 = (Ogre::HardwareOcclusionQuery *) 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_Ogre__HardwareOcclusionQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareOcclusionQuery *","beginOcclusionQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareOcclusionQuery * >(argp1);
  (arg1)->beginOcclusionQuery();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_endOcclusionQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareOcclusionQuery *arg1 = (Ogre::HardwareOcclusionQuery *) 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_Ogre__HardwareOcclusionQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareOcclusionQuery *","endOcclusionQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareOcclusionQuery * >(argp1);
  (arg1)->endOcclusionQuery();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_pullOcclusionQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareOcclusionQuery *arg1 = (Ogre::HardwareOcclusionQuery *) 0 ;
  unsigned int *arg2 = (unsigned int *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__HardwareOcclusionQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareOcclusionQuery *","pullOcclusionQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareOcclusionQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned int *","pullOcclusionQuery", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);
  result = (bool)(arg1)->pullOcclusionQuery(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_getLastQuerysPixelcount(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareOcclusionQuery *arg1 = (Ogre::HardwareOcclusionQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__HardwareOcclusionQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareOcclusionQuery const *","getLastQuerysPixelcount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareOcclusionQuery * >(argp1);
  result = (unsigned int)((Ogre::HardwareOcclusionQuery const *)arg1)->getLastQuerysPixelcount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwareOcclusionQuery_isStillOutstanding(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwareOcclusionQuery *arg1 = (Ogre::HardwareOcclusionQuery *) 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_Ogre__HardwareOcclusionQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwareOcclusionQuery *","isStillOutstanding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwareOcclusionQuery * >(argp1);
  result = (bool)(arg1)->isStillOutstanding();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassHardwarePixelBuffer;

SWIGINTERN void
free_Ogre_HardwarePixelBuffer(Ogre::HardwarePixelBuffer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_lock__SWIG_0_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::LockOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","lock", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","lock", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::LockOptions >(val4);
  result = (void *)(arg1)->lock(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_lock__SWIG_0_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::HardwareBuffer::LockOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::HardwareBuffer::LockOptions >(val2);
  result = (void *)(arg1)->lock(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_lock__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::Image::Box *arg2 = 0 ;
  Ogre::HardwareBuffer::LockOptions arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Ogre::PixelBox *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image::Box const &","lock", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image::Box const &","lock", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image::Box * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::HardwareBuffer::LockOptions >(val3);
  result = (Ogre::PixelBox *) &(arg1)->lock((Ogre::Image::Box const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_lock__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::HardwareBuffer::LockOptions arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","lock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","lock", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","lock", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::LockOptions","lock", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::LockOptions >(val4);
  result = (void *)(arg1)->lock(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_lock(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_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HardwarePixelBuffer_lock__SWIG_0_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Box, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_HardwarePixelBuffer_lock__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 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_size_t(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_HardwarePixelBuffer_lock__SWIG_0_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 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_size_t(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_HardwarePixelBuffer_lock__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "HardwarePixelBuffer.lock", 
    "    void * HardwarePixelBuffer.lock(size_t offset, size_t length, Ogre::HardwareBuffer::LockOptions options)\n"
    "    void * HardwarePixelBuffer.lock(Ogre::HardwareBuffer::LockOptions options)\n"
    "    void * HardwarePixelBuffer.lock(Ogre::Image::Box const &lockBox, Ogre::HardwareBuffer::LockOptions options)\n"
    "    void * HardwarePixelBuffer.lock(size_t offset, size_t length, Ogre::HardwareBuffer::LockOptions options)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_getCurrentLock(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelBox *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","getCurrentLock", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  result = (Ogre::PixelBox *) &(arg1)->getCurrentLock();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_readData(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","readData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","readData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","readData", 4, argv[2] )); 
  }
  (arg1)->readData(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_writeData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","writeData", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->writeData(arg2,arg3,(void const *)arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_writeData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 ;
  
  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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","writeData", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void const *","writeData", 4, argv[2] )); 
  }
  (arg1)->writeData(arg2,arg3,(void const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_writeData(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HardwarePixelBuffer_writeData__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_HardwarePixelBuffer_writeData__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "HardwarePixelBuffer.writeData", 
    "    void HardwarePixelBuffer.writeData(size_t offset, size_t length, void const *pSource, bool discardWholeBuffer)\n"
    "    void HardwarePixelBuffer.writeData(size_t offset, size_t length, void const *pSource)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::HardwarePixelBufferSharedPtr *arg2 = 0 ;
  Ogre::Image::Box *arg3 = 0 ;
  Ogre::Image::Box *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","blit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBufferSharedPtr const &","blit", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwarePixelBufferSharedPtr const &","blit", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwarePixelBufferSharedPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Image::Box const &","blit", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image::Box const &","blit", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Image::Box * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image::Box const &","blit", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image::Box const &","blit", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Image::Box * >(argp4);
  (arg1)->blit((Ogre::HardwarePixelBufferSharedPtr const &)*arg2,(Ogre::Image::Box const &)*arg3,(Ogre::Image::Box const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::HardwarePixelBufferSharedPtr *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","blit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBufferSharedPtr const &","blit", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwarePixelBufferSharedPtr const &","blit", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::HardwarePixelBufferSharedPtr * >(argp2);
  (arg1)->blit((Ogre::HardwarePixelBufferSharedPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_blit(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_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwarePixelBuffer_blit__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Box, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Box, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_HardwarePixelBuffer_blit__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "HardwarePixelBuffer.blit", 
    "    void HardwarePixelBuffer.blit(Ogre::HardwarePixelBufferSharedPtr const &src, Ogre::Image::Box const &srcBox, Ogre::Image::Box const &dstBox)\n"
    "    void HardwarePixelBuffer.blit(Ogre::HardwarePixelBufferSharedPtr const &src)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blitFromMemory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  Ogre::Image::Box *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","blitFromMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","blitFromMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","blitFromMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Image::Box const &","blitFromMemory", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image::Box const &","blitFromMemory", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Image::Box * >(argp3);
  (arg1)->blitFromMemory((Ogre::PixelBox const &)*arg2,(Ogre::Image::Box const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blitFromMemory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::PixelBox *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","blitFromMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","blitFromMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","blitFromMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  (arg1)->blitFromMemory((Ogre::PixelBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_blitFromMemory(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_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwarePixelBuffer_blitFromMemory__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Box, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HardwarePixelBuffer_blitFromMemory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "HardwarePixelBuffer.blitFromMemory", 
    "    void HardwarePixelBuffer.blitFromMemory(Ogre::PixelBox const &src, Ogre::Image::Box const &dstBox)\n"
    "    void HardwarePixelBuffer.blitFromMemory(Ogre::PixelBox const &src)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blitToMemory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::Image::Box *arg2 = 0 ;
  Ogre::PixelBox *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","blitToMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image::Box const &","blitToMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image::Box const &","blitToMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image::Box * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","blitToMemory", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","blitToMemory", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::PixelBox * >(argp3);
  (arg1)->blitToMemory((Ogre::Image::Box const &)*arg2,(Ogre::PixelBox const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_blitToMemory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  Ogre::PixelBox *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","blitToMemory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","blitToMemory", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","blitToMemory", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  (arg1)->blitToMemory((Ogre::PixelBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_blitToMemory(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_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_HardwarePixelBuffer_blitToMemory__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Box, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_HardwarePixelBuffer_blitToMemory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "HardwarePixelBuffer.blitToMemory", 
    "    void HardwarePixelBuffer.blitToMemory(Ogre::Image::Box const &srcBox, Ogre::PixelBox const &dst)\n"
    "    void HardwarePixelBuffer.blitToMemory(Ogre::PixelBox const &dst)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_getRenderTarget__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::RenderTexture *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","getRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getRenderTarget", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::RenderTexture *)(arg1)->getRenderTarget(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTexture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_getRenderTarget__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderTexture *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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","getRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  result = (Ogre::RenderTexture *)(arg1)->getRenderTarget();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTexture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_HardwarePixelBuffer_getRenderTarget(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_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_HardwarePixelBuffer_getRenderTarget__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_HardwarePixelBuffer_getRenderTarget__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "HardwarePixelBuffer.getRenderTarget", 
    "    Ogre::RenderTexture * HardwarePixelBuffer.getRenderTarget(size_t slice)\n"
    "    Ogre::RenderTexture * HardwarePixelBuffer.getRenderTarget()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_getWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer const *","getWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  result = ((Ogre::HardwarePixelBuffer const *)arg1)->getWidth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_getHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer const *","getHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  result = ((Ogre::HardwarePixelBuffer const *)arg1)->getHeight();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_getDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer const *","getDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  result = ((Ogre::HardwarePixelBuffer const *)arg1)->getDepth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HardwarePixelBuffer_getFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer const *","getFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::HardwarePixelBuffer const *)arg1)->getFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassHardwarePixelBufferSharedPtr;

SWIGINTERN VALUE
_wrap_new_HardwarePixelBufferSharedPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::HardwarePixelBufferSharedPtr";
  Ogre::HardwarePixelBufferSharedPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HardwarePixelBufferSharedPtr *)new Ogre::HardwarePixelBufferSharedPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_HardwarePixelBufferSharedPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HardwarePixelBuffer *arg1 = (Ogre::HardwarePixelBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::HardwarePixelBufferSharedPtr";
  Ogre::HardwarePixelBufferSharedPtr *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__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","Ogre::HardwarePixelBufferSharedPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp1);
  result = (Ogre::HardwarePixelBufferSharedPtr *)new Ogre::HardwarePixelBufferSharedPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HardwarePixelBufferSharedPtr(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_HardwarePixelBufferSharedPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HardwarePixelBuffer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HardwarePixelBufferSharedPtr__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HardwarePixelBufferSharedPtr.new", 
    "    HardwarePixelBufferSharedPtr.new()\n"
    "    HardwarePixelBufferSharedPtr.new(Ogre::HardwarePixelBuffer *buf)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_HardwarePixelBufferSharedPtr(Ogre::HardwarePixelBufferSharedPtr *arg1) {
    delete arg1;
}

swig_class SwigClassHighLevelGpuProgram;

SWIGINTERN void
free_Ogre_HighLevelGpuProgram(Ogre::HighLevelGpuProgram *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HighLevelGpuProgram_createParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgram *arg1 = (Ogre::HighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__HighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgram *","createParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgram * >(argp1);
  result = (arg1)->createParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgram__getBindingDelegate(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgram *arg1 = (Ogre::HighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgram *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_Ogre__HighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgram *","_getBindingDelegate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgram * >(argp1);
  result = (Ogre::GpuProgram *)(arg1)->_getBindingDelegate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgram, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgram_getConstantDefinitions(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgram *arg1 = (Ogre::HighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuNamedConstants *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_Ogre__HighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgram const *","getConstantDefinitions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgram * >(argp1);
  result = (Ogre::GpuNamedConstants *) &((Ogre::HighLevelGpuProgram const *)arg1)->getConstantDefinitions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgram_getNamedConstants(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgram *arg1 = (Ogre::HighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuNamedConstants *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_Ogre__HighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgram const *","getNamedConstants", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgram * >(argp1);
  result = (Ogre::GpuNamedConstants *) &((Ogre::HighLevelGpuProgram const *)arg1)->getNamedConstants();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuNamedConstants, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassHighLevelGpuProgramPtr;

SWIGINTERN VALUE
_wrap_new_HighLevelGpuProgramPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::HighLevelGpuProgramPtr";
  Ogre::HighLevelGpuProgramPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_HighLevelGpuProgramPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgram *arg1 = (Ogre::HighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::HighLevelGpuProgramPtr";
  Ogre::HighLevelGpuProgramPtr *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__HighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgram *","Ogre::HighLevelGpuProgramPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgram * >(argp1);
  result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_HighLevelGpuProgramPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::HighLevelGpuProgramPtr";
  Ogre::HighLevelGpuProgramPtr *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__HighLevelGpuProgramPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramPtr const &","Ogre::HighLevelGpuProgramPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HighLevelGpuProgramPtr const &","Ogre::HighLevelGpuProgramPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramPtr * >(argp1);
  result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr((Ogre::HighLevelGpuProgramPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_HighLevelGpuProgramPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::HighLevelGpuProgramPtr";
  Ogre::HighLevelGpuProgramPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::HighLevelGpuProgramPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::HighLevelGpuProgramPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::HighLevelGpuProgramPtr *)new Ogre::HighLevelGpuProgramPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_HighLevelGpuProgramPtr(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_HighLevelGpuProgramPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HighLevelGpuProgram, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HighLevelGpuProgramPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__HighLevelGpuProgramPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HighLevelGpuProgramPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_HighLevelGpuProgramPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "HighLevelGpuProgramPtr.new", 
    "    HighLevelGpuProgramPtr.new()\n"
    "    HighLevelGpuProgramPtr.new(Ogre::HighLevelGpuProgram *rep)\n"
    "    HighLevelGpuProgramPtr.new(Ogre::HighLevelGpuProgramPtr const &r)\n"
    "    HighLevelGpuProgramPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_HighLevelGpuProgramPtr(Ogre::HighLevelGpuProgramPtr *arg1) {
    delete arg1;
}

swig_class SwigClassHighLevelGpuProgramFactory;

SWIGINTERN void
free_Ogre_HighLevelGpuProgramFactory(Ogre::HighLevelGpuProgramFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HighLevelGpuProgramFactory_getLanguage(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramFactory *arg1 = (Ogre::HighLevelGpuProgramFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__HighLevelGpuProgramFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramFactory const *","getLanguage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::HighLevelGpuProgramFactory const *)arg1)->getLanguage();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgramFactory_create(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramFactory *arg1 = (Ogre::HighLevelGpuProgramFactory *) 0 ;
  Ogre::ResourceManager *arg2 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::ResourceHandle arg4 ;
  Ogre::String *arg5 = 0 ;
  bool arg6 ;
  Ogre::ManualResourceLoader *arg7 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  unsigned long long val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  bool val6 ;
  int ecode6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Ogre::HighLevelGpuProgram *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__HighLevelGpuProgramFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramFactory *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","create", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ResourceManager * >(argp2);
  {
    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 &","create", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","create", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::ResourceHandle >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","create", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","create", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","create", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp7);
  result = (Ogre::HighLevelGpuProgram *)(arg1)->create(arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HighLevelGpuProgram, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgramFactory_destroy(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramFactory *arg1 = (Ogre::HighLevelGpuProgramFactory *) 0 ;
  Ogre::HighLevelGpuProgram *arg2 = (Ogre::HighLevelGpuProgram *) 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_Ogre__HighLevelGpuProgramFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramFactory *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgram *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HighLevelGpuProgram * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassHighLevelGpuProgramManager;

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

SWIGINTERN VALUE
_wrap_new_HighLevelGpuProgramManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::HighLevelGpuProgramManager";
  Ogre::HighLevelGpuProgramManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HighLevelGpuProgramManager *)new Ogre::HighLevelGpuProgramManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_HighLevelGpuProgramManager(Ogre::HighLevelGpuProgramManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_addFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramManager *arg1 = (Ogre::HighLevelGpuProgramManager *) 0 ;
  Ogre::HighLevelGpuProgramFactory *arg2 = (Ogre::HighLevelGpuProgramFactory *) 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_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramManager *","addFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HighLevelGpuProgramFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramFactory *","addFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HighLevelGpuProgramFactory * >(argp2);
  (arg1)->addFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_removeFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramManager *arg1 = (Ogre::HighLevelGpuProgramManager *) 0 ;
  Ogre::HighLevelGpuProgramFactory *arg2 = (Ogre::HighLevelGpuProgramFactory *) 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_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramManager *","removeFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__HighLevelGpuProgramFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramFactory *","removeFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::HighLevelGpuProgramFactory * >(argp2);
  (arg1)->removeFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_isLanguageSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramManager *arg1 = (Ogre::HighLevelGpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramManager *","isLanguageSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramManager * >(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( "", "Ogre::String const &","isLanguageSupported", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","isLanguageSupported", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->isLanguageSupported((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_createProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramManager *arg1 = (Ogre::HighLevelGpuProgramManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::GpuProgramType arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::HighLevelGpuProgramPtr result;
  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_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::HighLevelGpuProgramManager *","createProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::HighLevelGpuProgramManager * >(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( "", "Ogre::String const &","createProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgram", 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 &","createProgram", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgram", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createProgram", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createProgram", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","createProgram", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::GpuProgramType >(val5);
  result = (arg1)->createProgram((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::HighLevelGpuProgramPtr(static_cast< const Ogre::HighLevelGpuProgramPtr& >(result))), SWIGTYPE_p_Ogre__HighLevelGpuProgramPtr, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HighLevelGpuProgramManager *) &Ogre::HighLevelGpuProgramManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_HighLevelGpuProgramManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::HighLevelGpuProgramManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::HighLevelGpuProgramManager *)Ogre::HighLevelGpuProgramManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HighLevelGpuProgramManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassInstanceBatch;

SWIGINTERN void
free_Ogre_InstanceBatch(Ogre::InstanceBatch *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstanceBatch__getMeshRef(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_getMeshRef", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::MeshPtr *) &(arg1)->_getMeshRef();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__setInstancesPerBatch(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_setInstancesPerBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_setInstancesPerBatch", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->_setInstancesPerBatch(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__getIndexToBoneMap(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh::IndexMap *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","_getIndexToBoneMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::Mesh::IndexMap *)((Ogre::InstanceBatch const *)arg1)->_getIndexToBoneMap();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__supportsSkeletalAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","_supportsSkeletalAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (bool)((Ogre::InstanceBatch const *)arg1)->_supportsSkeletalAnimation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__updateBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_updateBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  (arg1)->_updateBounds();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_calculateMaxNumInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","calculateMaxNumInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","calculateMaxNumInstances", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","calculateMaxNumInstances", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = ((Ogre::InstanceBatch const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_build(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::RenderOperation 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","build", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  result = (arg1)->build((Ogre::SubMesh const *)arg2);
  vresult = SWIG_NewPointerObj((new Ogre::RenderOperation(static_cast< const Ogre::RenderOperation& >(result))), SWIGTYPE_p_Ogre__RenderOperation, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_buildFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::RenderOperation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","buildFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","buildFrom", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderOperation const &","buildFrom", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation const &","buildFrom", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::RenderOperation * >(argp3);
  (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__getMeshReference(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshPtr *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","_getMeshReference", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::MeshPtr *) &((Ogre::InstanceBatch const *)arg1)->_getMeshReference();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_isBatchFull(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","isBatchFull", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (bool)((Ogre::InstanceBatch const *)arg1)->isBatchFull();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_isBatchUnused(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","isBatchUnused", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (bool)((Ogre::InstanceBatch const *)arg1)->isBatchUnused();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getInstancedEntitiesInUse(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::InstanceBatch::InstancedEntityVec *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","getInstancedEntitiesInUse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstanceBatch::InstancedEntityVec &","getInstancedEntitiesInUse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::InstanceBatch::InstancedEntityVec &","getInstancedEntitiesInUse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::InstanceBatch::InstancedEntityVec * >(argp2);
  (arg1)->getInstancedEntitiesInUse(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__defragmentBatch(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  bool arg2 ;
  Ogre::InstanceBatch::InstancedEntityVec *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_defragmentBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_defragmentBatch", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::InstanceBatch::InstancedEntityVec &","_defragmentBatch", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::InstanceBatch::InstancedEntityVec &","_defragmentBatch", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::InstanceBatch::InstancedEntityVec * >(argp3);
  (arg1)->_defragmentBatch(arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__defragmentBatchDiscard(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_defragmentBatchDiscard", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  (arg1)->_defragmentBatchDiscard();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__boundsDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_boundsDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  (arg1)->_boundsDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_setStaticAndUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","setStaticAndUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setStaticAndUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setStaticAndUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_isStatic(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","isStatic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (bool)((Ogre::InstanceBatch const *)arg1)->isStatic();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_createInstancedEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::InstancedEntity *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","createInstancedEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::InstancedEntity *)(arg1)->createInstancedEntity();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_removeInstancedEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::InstancedEntity *arg2 = (Ogre::InstancedEntity *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","removeInstancedEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","removeInstancedEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::InstancedEntity * >(argp2);
  (arg1)->removeInstancedEntity(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_useBoneWorldMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","useBoneWorldMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (bool)((Ogre::InstanceBatch const *)arg1)->useBoneWorldMatrices();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__markTransformSharingDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_markTransformSharingDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  (arg1)->_markTransformSharingDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::InstanceBatch const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::RenderOperation *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::InstanceBatch const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::LightList *) &((Ogre::InstanceBatch const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::Technique *)((Ogre::InstanceBatch const *)arg1)->getTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::String *) &((Ogre::InstanceBatch const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::InstanceBatch const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  result = (Ogre::Real)((Ogre::InstanceBatch const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatch_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstanceBatch_visitRenderables(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_Ogre__InstanceBatch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstanceBatch_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstanceBatch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstanceBatch_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstanceBatch.visitRenderables", 
    "    void InstanceBatch.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void InstanceBatch.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


swig_class SwigClassInstanceBatchHW;

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

SWIGINTERN VALUE
_wrap_new_InstanceBatchHW(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::MeshPtr *arg2 = 0 ;
  Ogre::MaterialPtr *arg3 = 0 ;
  size_t arg4 ;
  Ogre::Mesh::IndexMap *arg5 = (Ogre::Mesh::IndexMap *) 0 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::InstanceBatchHW";
  Ogre::InstanceBatchHW *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","Ogre::InstanceBatchHW", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__MeshPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshPtr &","Ogre::InstanceBatchHW", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshPtr &","Ogre::InstanceBatchHW", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::MeshPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","Ogre::InstanceBatchHW", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","Ogre::InstanceBatchHW", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::MaterialPtr * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::InstanceBatchHW", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap const *","Ogre::InstanceBatchHW", 5, argv[4] )); 
  }
  arg5 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceBatchHW", 6, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceBatchHW", 6, argv[5])); 
    }
    arg6 = ptr;
  }
  result = (Ogre::InstanceBatchHW *)new Ogre::InstanceBatchHW(arg1,*arg2,(Ogre::MaterialPtr const &)*arg3,arg4,(Ogre::Mesh::IndexMap const *)arg5,(Ogre::String const &)*arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return self;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InstanceBatchHW(Ogre::InstanceBatchHW *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstanceBatchHW_calculateMaxNumInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW const *","calculateMaxNumInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","calculateMaxNumInstances", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","calculateMaxNumInstances", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = ((Ogre::InstanceBatchHW const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_buildFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::RenderOperation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW *","buildFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","buildFrom", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderOperation const &","buildFrom", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation const &","buildFrom", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::RenderOperation * >(argp3);
  (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW__boundsDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW *","_boundsDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  (arg1)->_boundsDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_setStaticAndUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW *","setStaticAndUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setStaticAndUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setStaticAndUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_isStatic(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW const *","isStatic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  result = (bool)((Ogre::InstanceBatchHW const *)arg1)->isStatic();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::InstanceBatchHW const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_getNumWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW const *","getNumWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  result = (unsigned short)((Ogre::InstanceBatchHW const *)arg1)->getNumWorldTransforms();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW *arg1 = (Ogre::InstanceBatchHW *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__InstanceBatchHW, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassBaseInstanceBatchVTF;

SWIGINTERN void
free_Ogre_BaseInstanceBatchVTF(Ogre::BaseInstanceBatchVTF *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_buildFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::RenderOperation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF *","buildFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","buildFrom", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderOperation const &","buildFrom", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation const &","buildFrom", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::RenderOperation * >(argp3);
  (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::BaseInstanceBatchVTF const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_getNumWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","getNumWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  result = (unsigned short)((Ogre::BaseInstanceBatchVTF const *)arg1)->getNumWorldTransforms();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_setBoneMatrixLookup(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  bool arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF *","setBoneMatrixLookup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBoneMatrixLookup", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setBoneMatrixLookup", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setBoneMatrixLookup(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_useBoneMatrixLookup(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","useBoneMatrixLookup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useBoneMatrixLookup();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_setBoneDualQuaternions(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF *","setBoneDualQuaternions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBoneDualQuaternions", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBoneDualQuaternions(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_useBoneDualQuaternions(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","useBoneDualQuaternions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useBoneDualQuaternions();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_setForceOneWeight(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF *","setForceOneWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setForceOneWeight", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setForceOneWeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_forceOneWeight(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","forceOneWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->forceOneWeight();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_setUseOneWeight(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF *","setUseOneWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseOneWeight", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseOneWeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_useOneWeight(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","useOneWeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useOneWeight();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_useBoneWorldMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","useBoneWorldMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  result = (bool)((Ogre::BaseInstanceBatchVTF const *)arg1)->useBoneWorldMatrices();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BaseInstanceBatchVTF_getMaxLookupTableInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::BaseInstanceBatchVTF *arg1 = (Ogre::BaseInstanceBatchVTF *) 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_Ogre__BaseInstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BaseInstanceBatchVTF const *","getMaxLookupTableInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BaseInstanceBatchVTF * >(argp1);
  result = ((Ogre::BaseInstanceBatchVTF const *)arg1)->getMaxLookupTableInstances();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassInstanceBatchVTF;

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

SWIGINTERN VALUE
_wrap_new_InstanceBatchVTF(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::MeshPtr *arg2 = 0 ;
  Ogre::MaterialPtr *arg3 = 0 ;
  size_t arg4 ;
  Ogre::Mesh::IndexMap *arg5 = (Ogre::Mesh::IndexMap *) 0 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::InstanceBatchVTF";
  Ogre::InstanceBatchVTF *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","Ogre::InstanceBatchVTF", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__MeshPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshPtr &","Ogre::InstanceBatchVTF", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshPtr &","Ogre::InstanceBatchVTF", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::MeshPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","Ogre::InstanceBatchVTF", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","Ogre::InstanceBatchVTF", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::MaterialPtr * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::InstanceBatchVTF", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap const *","Ogre::InstanceBatchVTF", 5, argv[4] )); 
  }
  arg5 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceBatchVTF", 6, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceBatchVTF", 6, argv[5])); 
    }
    arg6 = ptr;
  }
  result = (Ogre::InstanceBatchVTF *)new Ogre::InstanceBatchVTF(arg1,*arg2,(Ogre::MaterialPtr const &)*arg3,arg4,(Ogre::Mesh::IndexMap const *)arg5,(Ogre::String const &)*arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return self;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InstanceBatchVTF(Ogre::InstanceBatchVTF *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstanceBatchVTF_calculateMaxNumInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchVTF *arg1 = (Ogre::InstanceBatchVTF *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__InstanceBatchVTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchVTF const *","calculateMaxNumInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchVTF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","calculateMaxNumInstances", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","calculateMaxNumInstances", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = ((Ogre::InstanceBatchVTF const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassInstanceBatchHW_VTF;

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

SWIGINTERN VALUE
_wrap_new_InstanceBatchHW_VTF(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::MeshPtr *arg2 = 0 ;
  Ogre::MaterialPtr *arg3 = 0 ;
  size_t arg4 ;
  Ogre::Mesh::IndexMap *arg5 = (Ogre::Mesh::IndexMap *) 0 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::InstanceBatchHW_VTF";
  Ogre::InstanceBatchHW_VTF *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","Ogre::InstanceBatchHW_VTF", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__MeshPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshPtr &","Ogre::InstanceBatchHW_VTF", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshPtr &","Ogre::InstanceBatchHW_VTF", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::MeshPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","Ogre::InstanceBatchHW_VTF", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","Ogre::InstanceBatchHW_VTF", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::MaterialPtr * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::InstanceBatchHW_VTF", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap const *","Ogre::InstanceBatchHW_VTF", 5, argv[4] )); 
  }
  arg5 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceBatchHW_VTF", 6, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceBatchHW_VTF", 6, argv[5])); 
    }
    arg6 = ptr;
  }
  result = (Ogre::InstanceBatchHW_VTF *)new Ogre::InstanceBatchHW_VTF(arg1,*arg2,(Ogre::MaterialPtr const &)*arg3,arg4,(Ogre::Mesh::IndexMap const *)arg5,(Ogre::String const &)*arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return self;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InstanceBatchHW_VTF(Ogre::InstanceBatchHW_VTF *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstanceBatchHW_VTF_calculateMaxNumInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW_VTF *arg1 = (Ogre::InstanceBatchHW_VTF *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__InstanceBatchHW_VTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW_VTF const *","calculateMaxNumInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW_VTF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","calculateMaxNumInstances", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","calculateMaxNumInstances", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = ((Ogre::InstanceBatchHW_VTF const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_VTF__boundsDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW_VTF *arg1 = (Ogre::InstanceBatchHW_VTF *) 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_Ogre__InstanceBatchHW_VTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW_VTF *","_boundsDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW_VTF * >(argp1);
  (arg1)->_boundsDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_VTF_setStaticAndUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW_VTF *arg1 = (Ogre::InstanceBatchHW_VTF *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstanceBatchHW_VTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW_VTF *","setStaticAndUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW_VTF * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setStaticAndUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setStaticAndUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_VTF_isStatic(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW_VTF *arg1 = (Ogre::InstanceBatchHW_VTF *) 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_Ogre__InstanceBatchHW_VTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW_VTF const *","isStatic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW_VTF * >(argp1);
  result = (bool)((Ogre::InstanceBatchHW_VTF const *)arg1)->isStatic();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchHW_VTF__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchHW_VTF *arg1 = (Ogre::InstanceBatchHW_VTF *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__InstanceBatchHW_VTF, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchHW_VTF *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchHW_VTF * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassInstanceBatchShader;

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

SWIGINTERN VALUE
_wrap_new_InstanceBatchShader(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::MeshPtr *arg2 = 0 ;
  Ogre::MaterialPtr *arg3 = 0 ;
  size_t arg4 ;
  Ogre::Mesh::IndexMap *arg5 = (Ogre::Mesh::IndexMap *) 0 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::InstanceBatchShader";
  Ogre::InstanceBatchShader *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","Ogre::InstanceBatchShader", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__MeshPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshPtr &","Ogre::InstanceBatchShader", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshPtr &","Ogre::InstanceBatchShader", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::MeshPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","Ogre::InstanceBatchShader", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","Ogre::InstanceBatchShader", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::MaterialPtr * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::InstanceBatchShader", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  res5 = SWIG_ConvertPtr(argv[4], &argp5,SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Mesh::IndexMap const *","Ogre::InstanceBatchShader", 5, argv[4] )); 
  }
  arg5 = reinterpret_cast< Ogre::Mesh::IndexMap * >(argp5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceBatchShader", 6, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceBatchShader", 6, argv[5])); 
    }
    arg6 = ptr;
  }
  result = (Ogre::InstanceBatchShader *)new Ogre::InstanceBatchShader(arg1,*arg2,(Ogre::MaterialPtr const &)*arg3,arg4,(Ogre::Mesh::IndexMap const *)arg5,(Ogre::String const &)*arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return self;
fail:
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InstanceBatchShader(Ogre::InstanceBatchShader *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstanceBatchShader_calculateMaxNumInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchShader *arg1 = (Ogre::InstanceBatchShader *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t 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_Ogre__InstanceBatchShader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchShader const *","calculateMaxNumInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchShader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","calculateMaxNumInstances", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","calculateMaxNumInstances", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = ((Ogre::InstanceBatchShader const *)arg1)->calculateMaxNumInstances((Ogre::SubMesh const *)arg2,arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchShader_buildFrom(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchShader *arg1 = (Ogre::InstanceBatchShader *) 0 ;
  Ogre::SubMesh *arg2 = (Ogre::SubMesh *) 0 ;
  Ogre::RenderOperation *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__InstanceBatchShader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchShader *","buildFrom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchShader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","buildFrom", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderOperation const &","buildFrom", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation const &","buildFrom", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::RenderOperation * >(argp3);
  (arg1)->buildFrom((Ogre::SubMesh const *)arg2,(Ogre::RenderOperation const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchShader_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchShader *arg1 = (Ogre::InstanceBatchShader *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__InstanceBatchShader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchShader const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchShader * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::InstanceBatchShader const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceBatchShader_getNumWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatchShader *arg1 = (Ogre::InstanceBatchShader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__InstanceBatchShader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatchShader const *","getNumWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatchShader * >(argp1);
  result = (unsigned short)((Ogre::InstanceBatchShader const *)arg1)->getNumWorldTransforms();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassInstanceManager;

SWIGINTERN VALUE
_wrap_new_InstanceManager__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  Ogre::uint16 arg6 ;
  size_t arg7 ;
  unsigned short arg8 ;
  bool arg9 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  unsigned short val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::InstanceManager";
  Ogre::InstanceManager *result = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",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 &","Ogre::InstanceManager", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceManager", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::InstanceManager", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceManager", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceManager", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceManager", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceManager", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","Ogre::InstanceManager", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::InstanceManager", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::uint16 >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","Ogre::InstanceManager", 7, argv[6] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_short(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "unsigned short","Ogre::InstanceManager", 8, argv[7] ));
  } 
  arg8 = static_cast< unsigned short >(val8);
  ecode9 = SWIG_AsVal_bool(argv[8], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","Ogre::InstanceManager", 9, argv[8] ));
  } 
  arg9 = static_cast< bool >(val9);
  result = (Ogre::InstanceManager *)new Ogre::InstanceManager((Ogre::String const &)*arg1,arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_InstanceManager__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  Ogre::uint16 arg6 ;
  size_t arg7 ;
  unsigned short arg8 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  unsigned short val8 ;
  int ecode8 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::InstanceManager";
  Ogre::InstanceManager *result = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",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 &","Ogre::InstanceManager", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceManager", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::InstanceManager", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceManager", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceManager", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstanceManager", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstanceManager", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","Ogre::InstanceManager", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::InstanceManager", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::uint16 >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","Ogre::InstanceManager", 7, argv[6] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_short(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "unsigned short","Ogre::InstanceManager", 8, argv[7] ));
  } 
  arg8 = static_cast< unsigned short >(val8);
  result = (Ogre::InstanceManager *)new Ogre::InstanceManager((Ogre::String const &)*arg1,arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstanceManager(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs;
  if (argc > 9) SWIG_fail;
  for (ii = 0; (ii < argc); ++ii) {
    argv[ii] = args[ii];
  }
  if (argc == 8) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_short(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_new_InstanceManager__SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_short(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_new_InstanceManager__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "InstanceManager.new", 
    "    InstanceManager.new(Ogre::String const &customName, Ogre::SceneManager *sceneManager, Ogre::String const &meshName, Ogre::String const &groupName, Ogre::InstanceManager::InstancingTechnique instancingTechnique, Ogre::uint16 instancingFlags, size_t instancesPerBatch, unsigned short subMeshIdx, bool useBoneMatrixLookup)\n"
    "    InstanceManager.new(Ogre::String const &customName, Ogre::SceneManager *sceneManager, Ogre::String const &meshName, Ogre::String const &groupName, Ogre::InstanceManager::InstancingTechnique instancingTechnique, Ogre::uint16 instancingFlags, size_t instancesPerBatch, unsigned short subMeshIdx)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_InstanceManager(Ogre::InstanceManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstanceManager_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  result = (Ogre::String *) &((Ogre::InstanceManager const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_setInstancesPerBatch(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","setInstancesPerBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInstancesPerBatch", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setInstancesPerBatch(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_setMaxLookupTableInstances(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","setMaxLookupTableInstances", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setMaxLookupTableInstances", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setMaxLookupTableInstances(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_getMaxOrBestNumInstancesPerBatch(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::String arg2 ;
  size_t arg3 ;
  Ogre::uint16 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  size_t 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","getMaxOrBestNumInstancesPerBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "Ogre::String","getMaxOrBestNumInstancesPerBatch", 2, argv[0] )); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getMaxOrBestNumInstancesPerBatch", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","getMaxOrBestNumInstancesPerBatch", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  result = (arg1)->getMaxOrBestNumInstancesPerBatch(arg2,arg3,arg4);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_createInstancedEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::InstancedEntity *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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","createInstancedEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(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( "", "Ogre::String const &","createInstancedEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstancedEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::InstancedEntity *)(arg1)->createInstancedEntity((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_cleanupEmptyBatches(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","cleanupEmptyBatches", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  (arg1)->cleanupEmptyBatches();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_defragmentBatches(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","defragmentBatches", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","defragmentBatches", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->defragmentBatches(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_setSetting__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::InstanceManager::BatchSettingId arg2 ;
  bool arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","setSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::InstanceManager::BatchSettingId","setSetting", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::InstanceManager::BatchSettingId >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setSetting", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSetting", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSetting", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->setSetting(arg2,arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_setSetting__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::InstanceManager::BatchSettingId arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","setSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::InstanceManager::BatchSettingId","setSetting", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::InstanceManager::BatchSettingId >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setSetting", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setSetting(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstanceManager_setSetting(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_Ogre__InstanceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstanceManager_setSetting__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstanceManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InstanceManager_setSetting__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "InstanceManager.setSetting", 
    "    void InstanceManager.setSetting(Ogre::InstanceManager::BatchSettingId id, bool value, Ogre::String const &materialName)\n"
    "    void InstanceManager.setSetting(Ogre::InstanceManager::BatchSettingId id, bool value)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_getSetting(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::InstanceManager::BatchSettingId arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager const *","getSetting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::InstanceManager::BatchSettingId","getSetting", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::InstanceManager::BatchSettingId >(val2);
  {
    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 &","getSetting", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSetting", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)((Ogre::InstanceManager const *)arg1)->getSetting(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_hasSettings(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager const *","hasSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(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( "", "Ogre::String const &","hasSettings", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasSettings", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::InstanceManager const *)arg1)->hasSettings((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_setBatchesAsStaticAndUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","setBatchesAsStaticAndUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBatchesAsStaticAndUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBatchesAsStaticAndUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager__addDirtyBatch(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::InstanceBatch *arg2 = (Ogre::InstanceBatch *) 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","_addDirtyBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","_addDirtyBatch", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::InstanceBatch * >(argp2);
  (arg1)->_addDirtyBatch(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager__updateDirtyBatches(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","_updateDirtyBatches", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  (arg1)->_updateDirtyBatches();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_getInstanceBatchMapIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::InstanceManager::InstanceBatchVec,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::InstanceManager::InstanceBatchVec >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager const *","getInstanceBatchMapIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(argp1);
  result = ((Ogre::InstanceManager const *)arg1)->getInstanceBatchMapIterator();
  vresult = SWIG_NewPointerObj((new Ogre::InstanceManager::InstanceBatchMapIterator(static_cast< const Ogre::InstanceManager::InstanceBatchMapIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstanceManager_getInstanceBatchIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceManager *arg1 = (Ogre::InstanceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::InstanceBatch *,Ogre::STLAllocator< Ogre::InstanceBatch *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceManager const *","getInstanceBatchIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceManager * >(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( "", "Ogre::String const &","getInstanceBatchIterator", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getInstanceBatchIterator", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::InstanceManager const *)arg1)->getInstanceBatchIterator((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::InstanceManager::InstanceBatchIterator(static_cast< const Ogre::InstanceManager::InstanceBatchIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassInstancedEntity;

SWIGINTERN VALUE
_wrap_new_InstancedEntity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::InstancedEntity *arg3 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::InstancedEntity";
  Ogre::InstancedEntity *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","Ogre::InstancedEntity", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::InstancedEntity", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","Ogre::InstancedEntity", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::InstancedEntity * >(argp3);
  result = (Ogre::InstancedEntity *)new Ogre::InstancedEntity(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_InstancedEntity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstanceBatch *arg1 = (Ogre::InstanceBatch *) 0 ;
  Ogre::uint32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::InstancedEntity";
  Ogre::InstancedEntity *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__InstanceBatch, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstanceBatch *","Ogre::InstancedEntity", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::InstanceBatch * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::InstancedEntity", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  result = (Ogre::InstancedEntity *)new Ogre::InstancedEntity(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_InstancedEntity(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstanceBatch, 0);
    _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_InstancedEntity__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstanceBatch, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__InstancedEntity, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_InstancedEntity__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "InstancedEntity.new", 
    "    InstancedEntity.new(Ogre::InstanceBatch *batchOwner, Ogre::uint32 instanceID, Ogre::InstancedEntity *sharedTransformEntity)\n"
    "    InstancedEntity.new(Ogre::InstanceBatch *batchOwner, Ogre::uint32 instanceID)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_InstancedEntity(Ogre::InstancedEntity *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstancedEntity_shareTransformWith(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::InstancedEntity *arg2 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","shareTransformWith", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","shareTransformWith", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::InstancedEntity * >(argp2);
  result = (bool)(arg1)->shareTransformWith(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_stopSharingTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","stopSharingTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  (arg1)->stopSharingTransform();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__getOwner(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::InstanceBatch *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","_getOwner", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::InstanceBatch *)((Ogre::InstancedEntity const *)arg1)->_getOwner();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstanceBatch, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::String *) &((Ogre::InstancedEntity const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::InstancedEntity const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::Real)((Ogre::InstancedEntity const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::InstancedEntity const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__notifyMoved(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","_notifyMoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  (arg1)->_notifyMoved();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__notifyAttached__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAttached", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAttached(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__notifyAttached__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity__notifyAttached(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_Ogre__InstancedEntity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstancedEntity__notifyAttached__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedEntity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstancedEntity__notifyAttached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity._notifyAttached", 
    "    void InstancedEntity._notifyAttached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void InstancedEntity._notifyAttached(Ogre::Node *parent)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_visitRenderables(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_Ogre__InstancedEntity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstancedEntity_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedEntity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstancedEntity_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.visitRenderables", 
    "    void InstancedEntity.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void InstancedEntity.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_hasSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","hasSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (bool)((Ogre::InstancedEntity const *)arg1)->hasSkeleton();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonInstance *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::SkeletonInstance *)((Ogre::InstancedEntity const *)arg1)->getSkeleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::AnimationState *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(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( "", "Ogre::String const &","getAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::AnimationState *)((Ogre::InstancedEntity const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getAllAnimationStates(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimationStateSet *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getAllAnimationStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::AnimationStateSet *)((Ogre::InstancedEntity const *)arg1)->getAllAnimationStates();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__updateAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","_updateAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (bool)(arg1)->_updateAnimation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setTransformLookupNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setTransformLookupNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setTransformLookupNumber", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setTransformLookupNumber(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::InstancedEntity const *)arg1)->getPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(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);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Vector3 *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(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);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_setPosition(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_Ogre__InstancedEntity, 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_InstancedEntity_setPosition__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedEntity, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstancedEntity_setPosition__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.setPosition", 
    "    void InstancedEntity.setPosition(Ogre::Vector3 const &position, bool doUpdate)\n"
    "    void InstancedEntity.setPosition(Ogre::Vector3 const &position)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::Quaternion *) &((Ogre::InstancedEntity const *)arg1)->getOrientation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setOrientation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Quaternion *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(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);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setOrientation", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setOrientation((Ogre::Quaternion const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setOrientation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Quaternion *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(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);
  (arg1)->setOrientation((Ogre::Quaternion const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_setOrientation(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_Ogre__InstancedEntity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstancedEntity_setOrientation__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedEntity, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstancedEntity_setOrientation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.setOrientation", 
    "    void InstancedEntity.setOrientation(Ogre::Quaternion const &orientation, bool doUpdate)\n"
    "    void InstancedEntity.setOrientation(Ogre::Quaternion const &orientation)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getScale(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::InstancedEntity const *)arg1)->getScale();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setScale__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(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);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setScale", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setScale((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setScale__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  Ogre::Vector3 *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(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);
  (arg1)->setScale((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedEntity_setScale(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_Ogre__InstancedEntity, 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_InstancedEntity_setScale__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedEntity, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstancedEntity_setScale__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedEntity.setScale", 
    "    void InstancedEntity.setScale(Ogre::Vector3 const &scale, bool doUpdate)\n"
    "    void InstancedEntity.setScale(Ogre::Vector3 const &scale)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_getMaxScaleCoef(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","getMaxScaleCoef", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::Real)((Ogre::InstancedEntity const *)arg1)->getMaxScaleCoef();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_updateTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","updateTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  (arg1)->updateTransforms();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_isInUse(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","isInUse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (bool)((Ogre::InstancedEntity const *)arg1)->isInUse();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_setInUse(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","setInUse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInUse", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setInUse(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__getParentNodeFullTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","_getParentNodeFullTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::InstancedEntity const *)arg1)->_getParentNodeFullTransform();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity__getDerivedPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","_getDerivedPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::InstancedEntity const *)arg1)->_getDerivedPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedEntity_isInScene(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedEntity *arg1 = (Ogre::InstancedEntity *) 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_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedEntity const *","isInScene", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedEntity * >(argp1);
  result = (bool)((Ogre::InstancedEntity const *)arg1)->isInScene();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSimpleRenderable;

SWIGINTERN VALUE
_wrap_SimpleRenderable_setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(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( "", "Ogre::String const &","setMaterial", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterial", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterial((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::SimpleRenderable const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_setRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::RenderOperation *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","setRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation const &","setRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation const &","setRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->setRenderOperation((Ogre::RenderOperation const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::RenderOperation *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_setWorldTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::Matrix4 *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","setWorldTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(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 &","setWorldTransform", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","setWorldTransform", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->setWorldTransform((Ogre::Matrix4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::SimpleRenderable const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_setBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","setBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","setBoundingBox", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","setBoundingBox", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->setBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::SimpleRenderable const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SimpleRenderable_visitRenderables(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_Ogre__SimpleRenderable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SimpleRenderable_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SimpleRenderable, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SimpleRenderable_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SimpleRenderable.visitRenderables", 
    "    void SimpleRenderable.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void SimpleRenderable.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimpleRenderable(Ogre::SimpleRenderable *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SimpleRenderable_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  result = (Ogre::String *) &((Ogre::SimpleRenderable const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimpleRenderable_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::SimpleRenderable *arg1 = (Ogre::SimpleRenderable *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__SimpleRenderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimpleRenderable const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimpleRenderable * >(argp1);
  result = (Ogre::LightList *) &((Ogre::SimpleRenderable const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSkeletonInstance;

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

SWIGINTERN VALUE
_wrap_new_SkeletonInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::SkeletonInstance";
  Ogre::SkeletonInstance *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__SkeletonPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonPtr const &","Ogre::SkeletonInstance", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::SkeletonPtr const &","Ogre::SkeletonInstance", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonPtr * >(argp1);
  result = (Ogre::SkeletonInstance *)new Ogre::SkeletonInstance((Ogre::SkeletonPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SkeletonInstance(Ogre::SkeletonInstance *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SkeletonInstance_getNumAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","getNumAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  result = (unsigned short)((Ogre::SkeletonInstance const *)arg1)->getNumAnimations();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_getAnimation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Animation *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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","getAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->getAnimation(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance__getAnimationImpl__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LinkedSkeletonAnimationSource **arg3 = (Ogre::LinkedSkeletonAnimationSource **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Animation *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","_getAnimationImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","_getAnimationImpl", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getAnimationImpl", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource const **","_getAnimationImpl", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource ** >(argp3);
  result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance__getAnimationImpl__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","_getAnimationImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","_getAnimationImpl", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_getAnimationImpl", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->_getAnimationImpl((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonInstance__getAnimationImpl(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_Ogre__SkeletonInstance, 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_SkeletonInstance__getAnimationImpl__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SkeletonInstance__getAnimationImpl__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SkeletonInstance._getAnimationImpl", 
    "    Ogre::Animation * SkeletonInstance._getAnimationImpl(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * SkeletonInstance._getAnimationImpl(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_createAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Animation *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","createAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","createAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_getAnimation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::LinkedSkeletonAnimationSource **arg3 = (Ogre::LinkedSkeletonAnimationSource **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::Animation *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::LinkedSkeletonAnimationSource const **","getAnimation", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::LinkedSkeletonAnimationSource ** >(argp3);
  result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->getAnimation((Ogre::String const &)*arg2,(Ogre::LinkedSkeletonAnimationSource const **)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_getAnimation__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::SkeletonInstance const *)arg1)->getAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonInstance_getAnimation(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_Ogre__SkeletonInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SkeletonInstance_getAnimation__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonInstance, 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_SkeletonInstance_getAnimation__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_p_Ogre__LinkedSkeletonAnimationSource, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SkeletonInstance_getAnimation__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SkeletonInstance.getAnimation", 
    "    Ogre::Animation * SkeletonInstance.getAnimation(unsigned short index)\n"
    "    Ogre::Animation * SkeletonInstance.getAnimation(Ogre::String const &name, Ogre::LinkedSkeletonAnimationSource const **linker)\n"
    "    Ogre::Animation * SkeletonInstance.getAnimation(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_removeAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","removeAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","removeAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeAnimation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_createTagPointOnBone__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::Bone *arg2 = (Ogre::Bone *) 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::TagPoint *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","createTagPointOnBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Bone *","createTagPointOnBone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Bone * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createTagPointOnBone", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createTagPointOnBone", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(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 &","createTagPointOnBone", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createTagPointOnBone", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  result = (Ogre::TagPoint *)(arg1)->createTagPointOnBone(arg2,(Ogre::Quaternion const &)*arg3,(Ogre::Vector3 const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_createTagPointOnBone__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::Bone *arg2 = (Ogre::Bone *) 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::TagPoint *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","createTagPointOnBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Bone *","createTagPointOnBone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Bone * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createTagPointOnBone", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createTagPointOnBone", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  result = (Ogre::TagPoint *)(arg1)->createTagPointOnBone(arg2,(Ogre::Quaternion const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_createTagPointOnBone__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::Bone *arg2 = (Ogre::Bone *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::TagPoint *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","createTagPointOnBone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Bone, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Bone *","createTagPointOnBone", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Bone * >(argp2);
  result = (Ogre::TagPoint *)(arg1)->createTagPointOnBone(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonInstance_createTagPointOnBone(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_Ogre__SkeletonInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Bone, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SkeletonInstance_createTagPointOnBone__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Bone, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SkeletonInstance_createTagPointOnBone__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonInstance, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Bone, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Quaternion, 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_SkeletonInstance_createTagPointOnBone__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SkeletonInstance.createTagPointOnBone", 
    "    Ogre::TagPoint * SkeletonInstance.createTagPointOnBone(Ogre::Bone *bone, Ogre::Quaternion const &offsetOrientation, Ogre::Vector3 const &offsetPosition)\n"
    "    Ogre::TagPoint * SkeletonInstance.createTagPointOnBone(Ogre::Bone *bone, Ogre::Quaternion const &offsetOrientation)\n"
    "    Ogre::TagPoint * SkeletonInstance.createTagPointOnBone(Ogre::Bone *bone)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_freeTagPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::TagPoint *arg2 = (Ogre::TagPoint *) 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","freeTagPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TagPoint *","freeTagPoint", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TagPoint * >(argp2);
  (arg1)->freeTagPoint(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_addLinkedSkeletonAnimationSource__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","addLinkedSkeletonAnimationSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addLinkedSkeletonAnimationSource", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_addLinkedSkeletonAnimationSource__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","addLinkedSkeletonAnimationSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(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( "", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addLinkedSkeletonAnimationSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addLinkedSkeletonAnimationSource((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonInstance_addLinkedSkeletonAnimationSource(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_Ogre__SkeletonInstance, 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_SkeletonInstance_addLinkedSkeletonAnimationSource__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonInstance, 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_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SkeletonInstance_addLinkedSkeletonAnimationSource__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SkeletonInstance.addLinkedSkeletonAnimationSource", 
    "    void SkeletonInstance.addLinkedSkeletonAnimationSource(Ogre::String const &skelName, Ogre::Real scale)\n"
    "    void SkeletonInstance.addLinkedSkeletonAnimationSource(Ogre::String const &skelName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_removeAllLinkedSkeletonAnimationSources(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","removeAllLinkedSkeletonAnimationSources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  (arg1)->removeAllLinkedSkeletonAnimationSources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_getLinkedSkeletonAnimationSourceIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::LinkedSkeletonAnimationSource,Ogre::STLAllocator< Ogre::LinkedSkeletonAnimationSource,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","getLinkedSkeletonAnimationSourceIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  result = ((Ogre::SkeletonInstance const *)arg1)->getLinkedSkeletonAnimationSourceIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Skeleton::LinkedSkeletonAnimSourceIterator(static_cast< const Ogre::Skeleton::LinkedSkeletonAnimSourceIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance__initAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","_initAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_initAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (arg1)->_initAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance__refreshAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  Ogre::AnimationStateSet *arg2 = (Ogre::AnimationStateSet *) 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","_refreshAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AnimationStateSet *","_refreshAnimationState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AnimationStateSet * >(argp2);
  (arg1)->_refreshAnimationState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  result = (Ogre::String *) &((Ogre::SkeletonInstance const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_getHandle(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ResourceHandle 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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance const *","getHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  result = (Ogre::ResourceHandle)((Ogre::SkeletonInstance const *)arg1)->getHandle();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonInstance_getGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonInstance *arg1 = (Ogre::SkeletonInstance *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SkeletonInstance, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonInstance *","getGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonInstance * >(argp1);
  result = (Ogre::String *) &(arg1)->getGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassInstancedGeometry;

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

SWIGINTERN VALUE
_wrap_new_InstancedGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::InstancedGeometry";
  Ogre::InstancedGeometry *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::InstancedGeometry", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::InstancedGeometry", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::InstancedGeometry", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::InstancedGeometry *)new Ogre::InstancedGeometry(arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_InstancedGeometry(Ogre::InstancedGeometry *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_InstancedGeometry_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::String *) &((Ogre::InstancedGeometry const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_addEntity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","addEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","addEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(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 &","addEntity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","addEntity", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","addEntity", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addEntity", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Vector3 const &)*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_addEntity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","addEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","addEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(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 &","addEntity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","addEntity", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","addEntity", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_addEntity__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","addEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","addEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(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 &","addEntity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedGeometry_addEntity(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_Ogre__InstancedGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 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_InstancedGeometry_addEntity__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 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__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_InstancedGeometry_addEntity__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 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__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_InstancedGeometry_addEntity__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "InstancedGeometry.addEntity", 
    "    void InstancedGeometry.addEntity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation, Ogre::Vector3 const &scale)\n"
    "    void InstancedGeometry.addEntity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation)\n"
    "    void InstancedGeometry.addEntity(Ogre::Entity *ent, Ogre::Vector3 const &position)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_addSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","addSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","addSceneNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  (arg1)->addSceneNode((Ogre::SceneNode const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_build(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  (arg1)->build();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_addBatchInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","addBatchInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  (arg1)->addBatchInstance();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_destroy(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  (arg1)->destroy();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_setRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","setRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRenderingDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setRenderingDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","getRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::Real)((Ogre::InstancedGeometry const *)arg1)->getRenderingDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getSquaredRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","getSquaredRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::Real)((Ogre::InstancedGeometry const *)arg1)->getSquaredRenderingDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_setVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (bool)((Ogre::InstancedGeometry const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_setCastShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","setCastShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCastShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCastShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getCastShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","getCastShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (bool)(arg1)->getCastShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_setBatchInstanceDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Vector3 *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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","setBatchInstanceDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(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 &","setBatchInstanceDimensions", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setBatchInstanceDimensions", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setBatchInstanceDimensions((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getBatchInstanceDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","getBatchInstanceDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::InstancedGeometry const *)arg1)->getBatchInstanceDimensions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_setOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Vector3 *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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","setOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(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 &","setOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::InstancedGeometry const *)arg1)->getOrigin();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","getRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::uint8)((Ogre::InstancedGeometry const *)arg1)->getRenderQueueGroup();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getBatchInstanceIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::InstancedGeometry::BatchInstanceIterator > 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","getBatchInstanceIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (arg1)->getBatchInstanceIterator();
  vresult = SWIG_NewPointerObj((new Ogre::InstancedGeometry::BatchInstanceIterator(static_cast< const Ogre::InstancedGeometry::BatchInstanceIterator& >(result))), SWIGTYPE_p_Ogre__InstancedGeometry__BatchInstanceIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getRenderOperationVector(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::InstancedGeometry::RenderOperationVector *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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","getRenderOperationVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::InstancedGeometry::RenderOperationVector *) &(arg1)->getRenderOperationVector();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_InstancedGeometry_visitRenderables(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_Ogre__InstancedGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_InstancedGeometry_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__InstancedGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_InstancedGeometry_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "InstancedGeometry.visitRenderables", 
    "    void InstancedGeometry.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void InstancedGeometry.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_dump(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  Ogre::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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","dump", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(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( "", "Ogre::String const &","dump", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","dump", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ((Ogre::InstancedGeometry const *)arg1)->dump((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getBaseSkeletonInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonInstance *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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","getBaseSkeletonInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::SkeletonInstance *)(arg1)->getBaseSkeletonInstance();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonInstance, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getBaseSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SkeletonPtr 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","getBaseSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (arg1)->getBaseSkeleton();
  vresult = SWIG_NewPointerObj((new Ogre::SkeletonPtr(static_cast< const Ogre::SkeletonPtr& >(result))), SWIGTYPE_p_Ogre__SkeletonPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getBaseAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AnimationStateSet *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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","getBaseAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (Ogre::AnimationStateSet *)(arg1)->getBaseAnimationState();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationStateSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getObjectCount(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","getObjectCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (unsigned int)(arg1)->getObjectCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_setProvideWorldInverses(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","setProvideWorldInverses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setProvideWorldInverses", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setProvideWorldInverses(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_InstancedGeometry_getProvideWorldInverses(int argc, VALUE *argv, VALUE self) {
  Ogre::InstancedGeometry *arg1 = (Ogre::InstancedGeometry *) 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_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry const *","getProvideWorldInverses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::InstancedGeometry * >(argp1);
  result = (bool)((Ogre::InstancedGeometry const *)arg1)->getProvideWorldInverses();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMovableObjectLodChangedEvent;

SWIGINTERN VALUE
_wrap_MovableObjectLodChangedEvent_movableObject_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectLodChangedEvent *arg1 = (Ogre::MovableObjectLodChangedEvent *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__MovableObjectLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectLodChangedEvent *","movableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectLodChangedEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","movableObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  if (arg1) (arg1)->movableObject = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectLodChangedEvent_movableObject_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectLodChangedEvent *arg1 = (Ogre::MovableObjectLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MovableObject *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_Ogre__MovableObjectLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectLodChangedEvent *","movableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectLodChangedEvent * >(argp1);
  result = (Ogre::MovableObject *) ((arg1)->movableObject);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectLodChangedEvent_camera_set(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectLodChangedEvent *arg1 = (Ogre::MovableObjectLodChangedEvent *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__MovableObjectLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectLodChangedEvent *","camera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectLodChangedEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","camera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  if (arg1) (arg1)->camera = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MovableObjectLodChangedEvent_camera_get(int argc, VALUE *argv, VALUE self) {
  Ogre::MovableObjectLodChangedEvent *arg1 = (Ogre::MovableObjectLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Camera *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_Ogre__MovableObjectLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovableObjectLodChangedEvent *","camera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MovableObjectLodChangedEvent * >(argp1);
  result = (Ogre::Camera *) ((arg1)->camera);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_MovableObjectLodChangedEvent(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MovableObjectLodChangedEvent";
  Ogre::MovableObjectLodChangedEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MovableObjectLodChangedEvent *)new Ogre::MovableObjectLodChangedEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MovableObjectLodChangedEvent(Ogre::MovableObjectLodChangedEvent *arg1) {
    delete arg1;
}

swig_class SwigClassEntityMeshLodChangedEvent;

SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_entity_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","entity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","entity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(argp2);
  if (arg1) (arg1)->entity = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_entity_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Entity *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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","entity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  result = (Ogre::Entity *) ((arg1)->entity);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_camera_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","camera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","camera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  if (arg1) (arg1)->camera = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_camera_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Camera *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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","camera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  result = (Ogre::Camera *) ((arg1)->camera);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_lodValue_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","lodValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","lodValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->lodValue = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_lodValue_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","lodValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  result = (Ogre::Real) ((arg1)->lodValue);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_previousLodIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","previousLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","previousLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  if (arg1) (arg1)->previousLodIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_previousLodIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","previousLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  result = (Ogre::ushort) ((arg1)->previousLodIndex);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_newLodIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","newLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","newLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  if (arg1) (arg1)->newLodIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMeshLodChangedEvent_newLodIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMeshLodChangedEvent *arg1 = (Ogre::EntityMeshLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__EntityMeshLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent *","newLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp1);
  result = (Ogre::ushort) ((arg1)->newLodIndex);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_EntityMeshLodChangedEvent(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::EntityMeshLodChangedEvent";
  Ogre::EntityMeshLodChangedEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EntityMeshLodChangedEvent *)new Ogre::EntityMeshLodChangedEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EntityMeshLodChangedEvent(Ogre::EntityMeshLodChangedEvent *arg1) {
    delete arg1;
}

swig_class SwigClassEntityMaterialLodChangedEvent;

SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_subEntity_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  Ogre::SubEntity *arg2 = (Ogre::SubEntity *) 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","subEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SubEntity, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubEntity *","subEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubEntity * >(argp2);
  if (arg1) (arg1)->subEntity = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_subEntity_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SubEntity *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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","subEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  result = (Ogre::SubEntity *) ((arg1)->subEntity);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubEntity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_camera_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","camera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","camera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  if (arg1) (arg1)->camera = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_camera_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Camera *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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","camera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  result = (Ogre::Camera *) ((arg1)->camera);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_lodValue_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","lodValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","lodValue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->lodValue = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_lodValue_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","lodValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  result = (Ogre::Real) ((arg1)->lodValue);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_previousLodIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","previousLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","previousLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  if (arg1) (arg1)->previousLodIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_previousLodIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","previousLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  result = (Ogre::ushort) ((arg1)->previousLodIndex);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_newLodIndex_set(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","newLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","newLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  if (arg1) (arg1)->newLodIndex = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EntityMaterialLodChangedEvent_newLodIndex_get(int argc, VALUE *argv, VALUE self) {
  Ogre::EntityMaterialLodChangedEvent *arg1 = (Ogre::EntityMaterialLodChangedEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__EntityMaterialLodChangedEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent *","newLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp1);
  result = (Ogre::ushort) ((arg1)->newLodIndex);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_EntityMaterialLodChangedEvent(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::EntityMaterialLodChangedEvent";
  Ogre::EntityMaterialLodChangedEvent *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EntityMaterialLodChangedEvent *)new Ogre::EntityMaterialLodChangedEvent();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EntityMaterialLodChangedEvent(Ogre::EntityMaterialLodChangedEvent *arg1) {
    delete arg1;
}

swig_class SwigClassLodListener;

SWIGINTERN void
free_Ogre_LodListener(Ogre::LodListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LodListener_prequeueMovableObjectLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::LodListener *arg1 = (Ogre::LodListener *) 0 ;
  Ogre::MovableObjectLodChangedEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  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_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodListener *","prequeueMovableObjectLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MovableObjectLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObjectLodChangedEvent const &","prequeueMovableObjectLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MovableObjectLodChangedEvent const &","prequeueMovableObjectLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObjectLodChangedEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      result = (bool)(arg1)->Ogre::LodListener::prequeueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
    } else {
      result = (bool)(arg1)->prequeueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodListener_postqueueMovableObjectLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::LodListener *arg1 = (Ogre::LodListener *) 0 ;
  Ogre::MovableObjectLodChangedEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodListener *","postqueueMovableObjectLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MovableObjectLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObjectLodChangedEvent const &","postqueueMovableObjectLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MovableObjectLodChangedEvent const &","postqueueMovableObjectLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObjectLodChangedEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::LodListener::postqueueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
    } else {
      (arg1)->postqueueMovableObjectLodChanged((Ogre::MovableObjectLodChangedEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodListener_prequeueEntityMeshLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::LodListener *arg1 = (Ogre::LodListener *) 0 ;
  Ogre::EntityMeshLodChangedEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  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_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodListener *","prequeueEntityMeshLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__EntityMeshLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent &","prequeueEntityMeshLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::EntityMeshLodChangedEvent &","prequeueEntityMeshLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      result = (bool)(arg1)->Ogre::LodListener::prequeueEntityMeshLodChanged(*arg2);
    } else {
      result = (bool)(arg1)->prequeueEntityMeshLodChanged(*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodListener_postqueueEntityMeshLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::LodListener *arg1 = (Ogre::LodListener *) 0 ;
  Ogre::EntityMeshLodChangedEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodListener *","postqueueEntityMeshLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__EntityMeshLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent const &","postqueueEntityMeshLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::EntityMeshLodChangedEvent const &","postqueueEntityMeshLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::LodListener::postqueueEntityMeshLodChanged((Ogre::EntityMeshLodChangedEvent const &)*arg2);
    } else {
      (arg1)->postqueueEntityMeshLodChanged((Ogre::EntityMeshLodChangedEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodListener_prequeueEntityMaterialLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::LodListener *arg1 = (Ogre::LodListener *) 0 ;
  Ogre::EntityMaterialLodChangedEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  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_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodListener *","prequeueEntityMaterialLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__EntityMaterialLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent &","prequeueEntityMaterialLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::EntityMaterialLodChangedEvent &","prequeueEntityMaterialLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      result = (bool)(arg1)->Ogre::LodListener::prequeueEntityMaterialLodChanged(*arg2);
    } else {
      result = (bool)(arg1)->prequeueEntityMaterialLodChanged(*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodListener_postqueueEntityMaterialLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::LodListener *arg1 = (Ogre::LodListener *) 0 ;
  Ogre::EntityMaterialLodChangedEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodListener *","postqueueEntityMaterialLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__EntityMaterialLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent const &","postqueueEntityMaterialLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::EntityMaterialLodChangedEvent const &","postqueueEntityMaterialLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp2);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      (arg1)->Ogre::LodListener::postqueueEntityMaterialLodChanged((Ogre::EntityMaterialLodChangedEvent const &)*arg2);
    } else {
      (arg1)->postqueueEntityMaterialLodChanged((Ogre::EntityMaterialLodChangedEvent const &)*arg2);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_LodListener(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  const char *classname SWIGUNUSED = "Ogre::LodListener";
  Ogre::LodListener *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  arg1 = self;
  if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
    /* subclassed */
    result = (Ogre::LodListener *)new SwigDirector_LodListener(arg1); 
  } else {
    result = (Ogre::LodListener *)new Ogre::LodListener(); 
  }
  
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_disown_LodListener(int argc, VALUE *argv, VALUE self) {
  Ogre::LodListener *arg1 = (Ogre::LodListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodListener *","disown_LodListener", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::LodListener * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassLodStrategyManager;

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

SWIGINTERN VALUE
_wrap_new_LodStrategyManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::LodStrategyManager";
  Ogre::LodStrategyManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LodStrategyManager *)new Ogre::LodStrategyManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LodStrategyManager(Ogre::LodStrategyManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LodStrategyManager_addStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *arg1 = (Ogre::LodStrategyManager *) 0 ;
  Ogre::LodStrategy *arg2 = (Ogre::LodStrategy *) 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_Ogre__LodStrategyManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategyManager *","addStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategyManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodStrategy *","addStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodStrategy * >(argp2);
  (arg1)->addStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_removeStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *arg1 = (Ogre::LodStrategyManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::LodStrategy *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_Ogre__LodStrategyManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategyManager *","removeStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategyManager * >(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( "", "Ogre::String const &","removeStrategy", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeStrategy", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::LodStrategy *)(arg1)->removeStrategy((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_removeAllStrategies(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *arg1 = (Ogre::LodStrategyManager *) 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_Ogre__LodStrategyManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategyManager *","removeAllStrategies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategyManager * >(argp1);
  (arg1)->removeAllStrategies();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_getStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *arg1 = (Ogre::LodStrategyManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::LodStrategy *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_Ogre__LodStrategyManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategyManager *","getStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategyManager * >(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( "", "Ogre::String const &","getStrategy", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getStrategy", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::LodStrategy *)(arg1)->getStrategy((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_setDefaultStrategy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *arg1 = (Ogre::LodStrategyManager *) 0 ;
  Ogre::LodStrategy *arg2 = (Ogre::LodStrategy *) 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_Ogre__LodStrategyManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategyManager *","setDefaultStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategyManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodStrategy *","setDefaultStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodStrategy * >(argp2);
  (arg1)->setDefaultStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_setDefaultStrategy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *arg1 = (Ogre::LodStrategyManager *) 0 ;
  Ogre::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_Ogre__LodStrategyManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategyManager *","setDefaultStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategyManager * >(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( "", "Ogre::String const &","setDefaultStrategy", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setDefaultStrategy", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setDefaultStrategy((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_LodStrategyManager_setDefaultStrategy(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_Ogre__LodStrategyManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__LodStrategy, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_LodStrategyManager_setDefaultStrategy__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__LodStrategyManager, 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_LodStrategyManager_setDefaultStrategy__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "LodStrategyManager.setDefaultStrategy", 
    "    void LodStrategyManager.setDefaultStrategy(Ogre::LodStrategy *strategy)\n"
    "    void LodStrategyManager.setDefaultStrategy(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_getDefaultStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *arg1 = (Ogre::LodStrategyManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LodStrategy *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_Ogre__LodStrategyManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LodStrategyManager *","getDefaultStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LodStrategyManager * >(argp1);
  result = (Ogre::LodStrategy *)(arg1)->getDefaultStrategy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LodStrategyManager *) &Ogre::LodStrategyManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategyManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LodStrategyManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::LodStrategyManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LodStrategyManager *)Ogre::LodStrategyManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__LodStrategyManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassManualObject;

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

SWIGINTERN VALUE
_wrap_new_ManualObject(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::ManualObject";
  Ogre::ManualObject *result = 0 ;
  
  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 &","Ogre::ManualObject", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ManualObject", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::ManualObject *)new Ogre::ManualObject((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_ManualObject(Ogre::ManualObject *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::ManualObject.clear

  call-seq:
    clear

Clear ManualObject contents.
*/
SWIGINTERN VALUE
_wrap_ManualObject_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_estimateVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","estimateVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","estimateVertexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->estimateVertexCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_estimateIndexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","estimateIndexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","estimateIndexCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->estimateIndexCount(arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.begin

  call-seq:
    begin(materialName, opType=OT_TRIANGLE_LIST, groupName=DEFAULT_RESOURCE_GROUP_NAME)
    begin(materialName, opType=OT_TRIANGLE_LIST)
    begin(materialName)

Return an iterator to the beginning of the ManualObject.
*/
SWIGINTERN VALUE
_wrap_ManualObject_begin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::RenderOperation::OperationType arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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( "", "Ogre::String const &","begin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","begin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::RenderOperation::OperationType","begin", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::RenderOperation::OperationType >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","begin", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","begin", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->begin((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_begin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::RenderOperation::OperationType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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( "", "Ogre::String const &","begin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","begin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::RenderOperation::OperationType","begin", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::RenderOperation::OperationType >(val3);
  (arg1)->begin((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_begin__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","begin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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( "", "Ogre::String const &","begin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","begin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->begin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_begin(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_Ogre__ManualObject, 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_ManualObject_begin__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ManualObject_begin__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ManualObject_begin__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ManualObject.begin", 
    "    void ManualObject.begin(Ogre::String const &materialName, Ogre::RenderOperation::OperationType opType, Ogre::String const &groupName)\n"
    "    void ManualObject.begin(Ogre::String const &materialName, Ogre::RenderOperation::OperationType opType)\n"
    "    void ManualObject.begin(Ogre::String const &materialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_setDynamic(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","setDynamic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDynamic", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDynamic(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getDynamic(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getDynamic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (bool)((Ogre::ManualObject const *)arg1)->getDynamic();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_beginUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","beginUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","beginUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->beginUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_position__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Vector3 *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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);
  (arg1)->position((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_position__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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);
  (arg1)->position(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_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_Ogre__ManualObject, 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_ManualObject_position__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_position__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ManualObject.position", 
    "    void ManualObject.position(Ogre::Vector3 const &pos)\n"
    "    void ManualObject.position(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_normal__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Vector3 *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","normal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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);
  (arg1)->normal((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_normal__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","normal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","normal", 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","normal", 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","normal", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->normal(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_normal(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_Ogre__ManualObject, 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_ManualObject_normal__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_normal__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ManualObject.normal", 
    "    void ManualObject.normal(Ogre::Vector3 const &norm)\n"
    "    void ManualObject.normal(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_tangent__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Vector3 *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","tangent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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 &","tangent", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","tangent", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->tangent((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_tangent__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","tangent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","tangent", 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","tangent", 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","tangent", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->tangent(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_tangent(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_Ogre__ManualObject, 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_ManualObject_tangent__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_tangent__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ManualObject.tangent", 
    "    void ManualObject.tangent(Ogre::Vector3 const &tan)\n"
    "    void ManualObject.tangent(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_textureCoord__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","textureCoord", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->textureCoord(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_textureCoord__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","textureCoord", 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","textureCoord", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->textureCoord(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_textureCoord__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","textureCoord", 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","textureCoord", 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","textureCoord", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->textureCoord(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_textureCoord__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","textureCoord", 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","textureCoord", 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","textureCoord", 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","textureCoord", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->textureCoord(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_textureCoord__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Vector2 *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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);
  (arg1)->textureCoord((Ogre::Vector2 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_textureCoord__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Vector3 *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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 &","textureCoord", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","textureCoord", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->textureCoord((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_textureCoord__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Vector4 *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","textureCoord", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","textureCoord", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","textureCoord", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  (arg1)->textureCoord((Ogre::Vector4 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_textureCoord(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_Ogre__ManualObject, 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_ManualObject_textureCoord__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_textureCoord__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ManualObject_textureCoord__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ManualObject_textureCoord__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_textureCoord__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_textureCoord__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ManualObject_textureCoord__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ManualObject.textureCoord", 
    "    void ManualObject.textureCoord(Ogre::Real u)\n"
    "    void ManualObject.textureCoord(Ogre::Real u, Ogre::Real v)\n"
    "    void ManualObject.textureCoord(Ogre::Real u, Ogre::Real v, Ogre::Real w)\n"
    "    void ManualObject.textureCoord(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Real w)\n"
    "    void ManualObject.textureCoord(Ogre::Vector2 const &uv)\n"
    "    void ManualObject.textureCoord(Ogre::Vector3 const &uvw)\n"
    "    void ManualObject.textureCoord(Ogre::Vector4 const &xyzw)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_colour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::ColourValue *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","colour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","colour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","colour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->colour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_colour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","colour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","colour", 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","colour", 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","colour", 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","colour", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->colour(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_colour__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","colour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","colour", 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","colour", 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","colour", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->colour(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_colour(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_Ogre__ManualObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ManualObject_colour__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_colour__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ManualObject_colour__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ManualObject.colour", 
    "    void ManualObject.colour(Ogre::ColourValue const &col)\n"
    "    void ManualObject.colour(Ogre::Real r, Ogre::Real g, Ogre::Real b, Ogre::Real a)\n"
    "    void ManualObject.colour(Ogre::Real r, Ogre::Real g, Ogre::Real b)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_index(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::uint32 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","index", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","index", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->index(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_triangle(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","triangle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","triangle", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","triangle", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","triangle", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  (arg1)->triangle(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_quad(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::uint32 arg3 ;
  Ogre::uint32 arg4 ;
  Ogre::uint32 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","quad", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","quad", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","quad", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint32","quad", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint32","quad", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint32 >(val5);
  (arg1)->quad(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getCurrentVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getCurrentVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = ((Ogre::ManualObject const *)arg1)->getCurrentVertexCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getCurrentIndexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getCurrentIndexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = ((Ogre::ManualObject const *)arg1)->getCurrentIndexCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ManualObject.end

  call-seq:
    end -> ManualObjectSection

Return an iterator to past the end of the ManualObject.
*/
SWIGINTERN VALUE
_wrap_ManualObject_end(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ManualObject::ManualObjectSection *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (Ogre::ManualObject::ManualObjectSection *)(arg1)->end();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject__ManualObjectSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_setMaterialName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  size_t arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setMaterialName", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setMaterialName", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->setMaterialName(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_setMaterialName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  size_t arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setMaterialName", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setMaterialName(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_setMaterialName(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_Ogre__ManualObject, 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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ManualObject_setMaterialName__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ManualObject_setMaterialName__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ManualObject.setMaterialName", 
    "    void ManualObject.setMaterialName(size_t subindex, Ogre::String const &name, Ogre::String const &group)\n"
    "    void ManualObject.setMaterialName(size_t subindex, Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_convertToMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","convertToMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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( "", "Ogre::String const &","convertToMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","convertToMesh", 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 &","convertToMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","convertToMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->convertToMesh((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  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_ManualObject_convertToMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","convertToMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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( "", "Ogre::String const &","convertToMesh", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","convertToMesh", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->convertToMesh((Ogre::String const &)*arg2);
  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_ManualObject_convertToMesh(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_Ogre__ManualObject, 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_ManualObject_convertToMesh__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 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_ManualObject_convertToMesh__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ManualObject.convertToMesh", 
    "    Ogre::MeshPtr ManualObject.convertToMesh(Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    Ogre::MeshPtr ManualObject.convertToMesh(Ogre::String const &meshName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_setUseIdentityProjection(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","setUseIdentityProjection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseIdentityProjection", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseIdentityProjection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getUseIdentityProjection(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getUseIdentityProjection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (bool)((Ogre::ManualObject const *)arg1)->getUseIdentityProjection();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_setUseIdentityView(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","setUseIdentityView", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseIdentityView", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseIdentityView(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getUseIdentityView(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getUseIdentityView", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (bool)((Ogre::ManualObject const *)arg1)->getUseIdentityView();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_setBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","setBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","setBoundingBox", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","setBoundingBox", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->setBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getSection(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::ManualObject::ManualObjectSection *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(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","getSection", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Ogre::ManualObject::ManualObjectSection *)((Ogre::ManualObject const *)arg1)->getSection(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject__ManualObjectSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getNumSections(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getNumSections", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (unsigned int)((Ogre::ManualObject const *)arg1)->getNumSections();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_setKeepDeclarationOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","setKeepDeclarationOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setKeepDeclarationOrder", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setKeepDeclarationOrder(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getKeepDeclarationOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getKeepDeclarationOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (bool)((Ogre::ManualObject const *)arg1)->getKeepDeclarationOrder();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (Ogre::String *) &((Ogre::ManualObject const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::ManualObject const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (Ogre::Real)((Ogre::ManualObject const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::EdgeData *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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","getEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (Ogre::EdgeData *)(arg1)->getEdgeList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__EdgeData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_hasEdgeList(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","hasEdgeList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  result = (bool)(arg1)->hasEdgeList();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getShadowVolumeRenderableIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  unsigned long arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned long val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_long(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "unsigned long","getShadowVolumeRenderableIterator", 7, argv[5] ));
  } 
  arg7 = static_cast< unsigned long >(val7);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_getShadowVolumeRenderableIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  Ogre::Light *arg3 = (Ogre::Light *) 0 ;
  Ogre::HardwareIndexBufferSharedPtr *arg4 = (Ogre::HardwareIndexBufferSharedPtr *) 0 ;
  bool arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","getShadowVolumeRenderableIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","getShadowVolumeRenderableIterator", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowVolumeRenderableIterator", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Light * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr *","getShadowVolumeRenderableIterator", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","getShadowVolumeRenderableIterator", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","getShadowVolumeRenderableIterator", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->getShadowVolumeRenderableIterator(arg2,(Ogre::Light const *)arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ShadowCaster::ShadowRenderableListIterator(static_cast< const Ogre::ShadowCaster::ShadowRenderableListIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_getShadowVolumeRenderableIterator(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ManualObject_getShadowVolumeRenderableIterator__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Light, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_long(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_ManualObject_getShadowVolumeRenderableIterator__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "ManualObject.getShadowVolumeRenderableIterator", 
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ManualObject.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist, unsigned long flags)\n"
    "    Ogre::ShadowCaster::ShadowRenderableListIterator ManualObject.getShadowVolumeRenderableIterator(Ogre::ShadowTechnique shadowTechnique, Ogre::Light const *light, Ogre::HardwareIndexBufferSharedPtr *indexBuffer, bool extrudeVertices, Ogre::Real extrusionDist)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObject_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObject *arg1 = (Ogre::ManualObject *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__ManualObject, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObject *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObject * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ManualObject_visitRenderables(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_Ogre__ManualObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ManualObject_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ManualObject, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ManualObject_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ManualObject.visitRenderables", 
    "    void ManualObject.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void ManualObject.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


swig_class SwigClassManualObjectFactory;

SWIGINTERN void
free_Ogre_ManualObjectFactory(Ogre::ManualObjectFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ManualObjectFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ManualObjectFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_ManualObjectFactory_FACTORY_TYPE_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ManualObjectFactory::FACTORY_TYPE_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::ManualObjectFactory::FACTORY_TYPE_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObjectFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObjectFactory *arg1 = (Ogre::ManualObjectFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ManualObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObjectFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObjectFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::ManualObjectFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ManualObjectFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::ManualObjectFactory *arg1 = (Ogre::ManualObjectFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__ManualObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ManualObjectFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ManualObjectFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassNedPoolingImpl;

SWIGINTERN VALUE
_wrap_NedPoolingImpl_allocBytes(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingImpl::allocBytes", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingImpl::allocBytes", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Ogre::NedPoolingImpl::allocBytes", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingImpl::allocBytes", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  result = (void *)Ogre::NedPoolingImpl::allocBytes(arg1,(char const *)arg2,arg3,(char const *)arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingImpl_deallocBytes(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::NedPoolingImpl::deallocBytes", 1, argv[0] )); 
  }
  Ogre::NedPoolingImpl::deallocBytes(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingImpl_allocBytesAligned(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t arg2 ;
  char *arg3 = (char *) 0 ;
  int arg4 ;
  char *arg5 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 ;
  char *buf3 = 0 ;
  int alloc3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 ;
  char *buf5 = 0 ;
  int alloc5 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingImpl::allocBytesAligned", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingImpl::allocBytesAligned", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_AsCharPtrAndSize(argv[2], &buf3, NULL, &alloc3);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingImpl::allocBytesAligned", 3, argv[2] ));
  }
  arg3 = reinterpret_cast< char * >(buf3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","Ogre::NedPoolingImpl::allocBytesAligned", 4, argv[3] ));
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_AsCharPtrAndSize(argv[4], &buf5, NULL, &alloc5);
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingImpl::allocBytesAligned", 5, argv[4] ));
  }
  arg5 = reinterpret_cast< char * >(buf5);
  result = (void *)Ogre::NedPoolingImpl::allocBytesAligned(arg1,arg2,(char const *)arg3,arg4,(char const *)arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return vresult;
fail:
  if (alloc3 == SWIG_NEWOBJ) delete[] buf3;
  if (alloc5 == SWIG_NEWOBJ) delete[] buf5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingImpl_deallocBytesAligned(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  void *arg2 = (void *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingImpl::deallocBytesAligned", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","Ogre::NedPoolingImpl::deallocBytesAligned", 2, argv[1] )); 
  }
  Ogre::NedPoolingImpl::deallocBytesAligned(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_NedPoolingImpl(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::NedPoolingImpl";
  Ogre::NedPoolingImpl *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::NedPoolingImpl *)new Ogre::NedPoolingImpl();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NedPoolingImpl(Ogre::NedPoolingImpl *arg1) {
    delete arg1;
}

swig_class SwigClassNedPoolingPolicy;

SWIGINTERN VALUE
_wrap_NedPoolingPolicy_allocateBytes__SWIG_0(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  char *arg4 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingPolicy::allocateBytes", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingPolicy::allocateBytes", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Ogre::NedPoolingPolicy::allocateBytes", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  res4 = SWIG_AsCharPtrAndSize(argv[3], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingPolicy::allocateBytes", 4, argv[3] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1,(char const *)arg2,arg3,(char const *)arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingPolicy_allocateBytes__SWIG_1(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  int arg3 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingPolicy::allocateBytes", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingPolicy::allocateBytes", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  ecode3 = SWIG_AsVal_int(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","Ogre::NedPoolingPolicy::allocateBytes", 3, argv[2] ));
  } 
  arg3 = static_cast< int >(val3);
  result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1,(char const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingPolicy_allocateBytes__SWIG_2(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  char *arg2 = (char *) 0 ;
  size_t val1 ;
  int ecode1 = 0 ;
  int res2 ;
  char *buf2 = 0 ;
  int alloc2 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingPolicy::allocateBytes", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  res2 = SWIG_AsCharPtrAndSize(argv[1], &buf2, NULL, &alloc2);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "char const *","Ogre::NedPoolingPolicy::allocateBytes", 2, argv[1] ));
  }
  arg2 = reinterpret_cast< char * >(buf2);
  result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1,(char const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return vresult;
fail:
  if (alloc2 == SWIG_NEWOBJ) delete[] buf2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingPolicy_allocateBytes__SWIG_3(int argc, VALUE *argv, VALUE self) {
  size_t arg1 ;
  size_t val1 ;
  int ecode1 = 0 ;
  void *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_size_t(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "size_t","Ogre::NedPoolingPolicy::allocateBytes", 1, argv[0] ));
  } 
  arg1 = static_cast< size_t >(val1);
  result = (void *)Ogre::NedPoolingPolicy::allocateBytes(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_NedPoolingPolicy_allocateBytes(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 == 1) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_NedPoolingPolicy_allocateBytes__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_NedPoolingPolicy_allocateBytes__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_NedPoolingPolicy_allocateBytes__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_size_t(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      int res = SWIG_AsCharPtrAndSize(argv[1], 0, NULL, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsCharPtrAndSize(argv[3], 0, NULL, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_NedPoolingPolicy_allocateBytes__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "NedPoolingPolicy.allocateBytes", 
    "    void * NedPoolingPolicy.allocateBytes(size_t count, char const *file, int line, char const *func)\n"
    "    void * NedPoolingPolicy.allocateBytes(size_t count, char const *file, int line)\n"
    "    void * NedPoolingPolicy.allocateBytes(size_t count, char const *file)\n"
    "    void * NedPoolingPolicy.allocateBytes(size_t count)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingPolicy_deallocateBytes(int argc, VALUE *argv, VALUE self) {
  void *arg1 = (void *) 0 ;
  int res1 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg1), 0, 0);
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "void *","Ogre::NedPoolingPolicy::deallocateBytes", 1, argv[0] )); 
  }
  Ogre::NedPoolingPolicy::deallocateBytes(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_NedPoolingPolicy_getMaxAllocationSize(int argc, VALUE *argv, VALUE self) {
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = Ogre::NedPoolingPolicy::getMaxAllocationSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_NedPoolingPolicy(Ogre::NedPoolingPolicy *arg1) {
    delete arg1;
}

swig_class SwigClassPatchSurface;

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

SWIGINTERN VALUE
_wrap_new_PatchSurface(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PatchSurface";
  Ogre::PatchSurface *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PatchSurface *)new Ogre::PatchSurface();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PatchSurface(Ogre::PatchSurface *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PatchSurface_defineSurface__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PatchSurface::PatchSurfaceType arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  Ogre::PatchSurface::VisibleSide arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","defineSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","defineSurface", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","defineSurface", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","defineSurface", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","defineSurface", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PatchSurface::PatchSurfaceType","defineSurface", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PatchSurface::PatchSurfaceType >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","defineSurface", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","defineSurface", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","defineSurface", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::PatchSurface::VisibleSide >(val9);
  (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_defineSurface__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PatchSurface::PatchSurfaceType arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","defineSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","defineSurface", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","defineSurface", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","defineSurface", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","defineSurface", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PatchSurface::PatchSurfaceType","defineSurface", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PatchSurface::PatchSurfaceType >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","defineSurface", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","defineSurface", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_defineSurface__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PatchSurface::PatchSurfaceType arg6 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","defineSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","defineSurface", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","defineSurface", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","defineSurface", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","defineSurface", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PatchSurface::PatchSurfaceType","defineSurface", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PatchSurface::PatchSurfaceType >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","defineSurface", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_defineSurface__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  Ogre::PatchSurface::PatchSurfaceType arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","defineSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","defineSurface", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","defineSurface", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","defineSurface", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","defineSurface", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::PatchSurface::PatchSurfaceType","defineSurface", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::PatchSurface::PatchSurfaceType >(val6);
  (arg1)->defineSurface(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_defineSurface__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","defineSurface", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","defineSurface", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","defineSurface", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","defineSurface", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","defineSurface", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->defineSurface(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PatchSurface_defineSurface(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[10];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 10) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchSurface, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_PatchSurface_defineSurface__SWIG_4(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchSurface, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(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_PatchSurface_defineSurface__SWIG_3(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchSurface, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_PatchSurface_defineSurface__SWIG_2(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchSurface, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_PatchSurface_defineSurface__SWIG_1(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchSurface, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_PatchSurface_defineSurface__SWIG_0(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 10, "PatchSurface.defineSurface", 
    "    void PatchSurface.defineSurface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, Ogre::PatchSurface::PatchSurfaceType pType, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide)\n"
    "    void PatchSurface.defineSurface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, Ogre::PatchSurface::PatchSurfaceType pType, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel)\n"
    "    void PatchSurface.defineSurface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, Ogre::PatchSurface::PatchSurfaceType pType, size_t uMaxSubdivisionLevel)\n"
    "    void PatchSurface.defineSurface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, Ogre::PatchSurface::PatchSurfaceType pType)\n"
    "    void PatchSurface.defineSurface(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getRequiredVertexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getRequiredVertexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = ((Ogre::PatchSurface const *)arg1)->getRequiredVertexCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getRequiredIndexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getRequiredIndexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = ((Ogre::PatchSurface const *)arg1)->getRequiredIndexCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getCurrentIndexCount(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getCurrentIndexCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = ((Ogre::PatchSurface const *)arg1)->getCurrentIndexCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getIndexOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getIndexOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = ((Ogre::PatchSurface const *)arg1)->getIndexOffset();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getVertexOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getVertexOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = ((Ogre::PatchSurface const *)arg1)->getVertexOffset();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::PatchSurface const *)arg1)->getBounds();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getBoundingSphereRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getBoundingSphereRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = (Ogre::Real)((Ogre::PatchSurface const *)arg1)->getBoundingSphereRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_build(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  Ogre::HardwareVertexBufferSharedPtr arg2 ;
  size_t arg3 ;
  Ogre::HardwareIndexBufferSharedPtr arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::HardwareVertexBufferSharedPtr","build", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareVertexBufferSharedPtr","build", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::HardwareVertexBufferSharedPtr * >(argp2));
    }
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","build", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr,  0 );
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::HardwareIndexBufferSharedPtr","build", 4, argv[2] )); 
    }  
    if (!argp4) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::HardwareIndexBufferSharedPtr","build", 4, argv[2]));
    } else {
      arg4 = *(reinterpret_cast< Ogre::HardwareIndexBufferSharedPtr * >(argp4));
    }
  }
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","build", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->build(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_setSubdivisionFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","setSubdivisionFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSubdivisionFactor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSubdivisionFactor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getSubdivisionFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getSubdivisionFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = (Ogre::Real)((Ogre::PatchSurface const *)arg1)->getSubdivisionFactor();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_getControlPointBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface const *","getControlPointBuffer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  result = (void *)((Ogre::PatchSurface const *)arg1)->getControlPointBuffer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_void, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchSurface_notifyControlPointBufferDeallocated(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchSurface *arg1 = (Ogre::PatchSurface *) 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_Ogre__PatchSurface, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","notifyControlPointBufferDeallocated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchSurface * >(argp1);
  (arg1)->notifyControlPointBufferDeallocated();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPatchMesh;

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

SWIGINTERN VALUE
_wrap_new_PatchMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::PatchMesh";
  Ogre::PatchMesh *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::PatchMesh", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::PatchMesh", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PatchMesh", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::PatchMesh", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::PatchMesh", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PatchMesh", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::PatchMesh *)new Ogre::PatchMesh(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_update(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  Ogre::PatchSurface::VisibleSide arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","update", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","update", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","update", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","update", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","update", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","update", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::PatchSurface::VisibleSide >(val7);
  (arg1)->update(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  size_t arg7 ;
  Ogre::PatchSurface::VisibleSide arg8 ;
  Ogre::HardwareBuffer::Usage arg9 ;
  Ogre::HardwareBuffer::Usage arg10 ;
  bool arg11 ;
  bool arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  bool val12 ;
  int ecode12 = 0 ;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","define", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","define", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","define", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PatchSurface::VisibleSide >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","define", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::HardwareBuffer::Usage >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","define", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::HardwareBuffer::Usage >(val10);
  ecode11 = SWIG_AsVal_bool(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "bool","define", 11, argv[9] ));
  } 
  arg11 = static_cast< bool >(val11);
  ecode12 = SWIG_AsVal_bool(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "bool","define", 12, argv[10] ));
  } 
  arg12 = static_cast< bool >(val12);
  (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  size_t arg7 ;
  Ogre::PatchSurface::VisibleSide arg8 ;
  Ogre::HardwareBuffer::Usage arg9 ;
  Ogre::HardwareBuffer::Usage arg10 ;
  bool arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  bool val11 ;
  int ecode11 = 0 ;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","define", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","define", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","define", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PatchSurface::VisibleSide >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","define", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::HardwareBuffer::Usage >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","define", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::HardwareBuffer::Usage >(val10);
  ecode11 = SWIG_AsVal_bool(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "bool","define", 11, argv[9] ));
  } 
  arg11 = static_cast< bool >(val11);
  (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  size_t arg7 ;
  Ogre::PatchSurface::VisibleSide arg8 ;
  Ogre::HardwareBuffer::Usage arg9 ;
  Ogre::HardwareBuffer::Usage arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","define", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","define", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","define", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PatchSurface::VisibleSide >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","define", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::HardwareBuffer::Usage >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","define", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::HardwareBuffer::Usage >(val10);
  (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  size_t arg7 ;
  Ogre::PatchSurface::VisibleSide arg8 ;
  Ogre::HardwareBuffer::Usage arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","define", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","define", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","define", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PatchSurface::VisibleSide >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","define", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::HardwareBuffer::Usage >(val9);
  (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  size_t arg7 ;
  Ogre::PatchSurface::VisibleSide arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","define", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","define", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","define", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::PatchSurface::VisibleSide >(val8);
  (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","define", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","define", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  (arg1)->define(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","define", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  (arg1)->define(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_define__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::VertexDeclaration *arg3 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg4 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","define", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","define", 2, argv[0] )); 
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","define", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VertexDeclaration * >(argp3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","define", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","define", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->define(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PatchMesh_define(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[13];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 13) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_PatchMesh_define__SWIG_7(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_PatchMesh_define__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_PatchMesh_define__SWIG_5(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_PatchMesh_define__SWIG_4(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_PatchMesh_define__SWIG_3(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_PatchMesh_define__SWIG_2(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_PatchMesh_define__SWIG_1(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *ptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &ptr, 0, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_size_t(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_size_t(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_bool(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_bool(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_PatchMesh_define__SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "PatchMesh.define", 
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage, Ogre::HardwareBuffer::Usage ibUsage, bool vbUseShadow, bool ibUseShadow)\n"
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage, Ogre::HardwareBuffer::Usage ibUsage, bool vbUseShadow)\n"
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage, Ogre::HardwareBuffer::Usage ibUsage)\n"
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage)\n"
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide)\n"
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel)\n"
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel)\n"
    "    void PatchMesh.define(void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PatchMesh_setSubdivision(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","setSubdivision", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSubdivision", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSubdivision(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PatchMesh(Ogre::PatchMesh *arg1) {
    delete arg1;
}

swig_class SwigClassPatchMeshPtr;

SWIGINTERN VALUE
_wrap_new_PatchMeshPtr__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PatchMeshPtr";
  Ogre::PatchMeshPtr *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_PatchMeshPtr__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMesh *arg1 = (Ogre::PatchMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PatchMeshPtr";
  Ogre::PatchMeshPtr *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__PatchMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMesh *","Ogre::PatchMeshPtr", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMesh * >(argp1);
  result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_PatchMeshPtr__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PatchMeshPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PatchMeshPtr";
  Ogre::PatchMeshPtr *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__PatchMeshPtr,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PatchMeshPtr const &","Ogre::PatchMeshPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PatchMeshPtr const &","Ogre::PatchMeshPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::PatchMeshPtr * >(argp1);
  result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr((Ogre::PatchMeshPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PatchMeshPtr__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourcePtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PatchMeshPtr";
  Ogre::PatchMeshPtr *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__SharedPtrT_Ogre__Resource_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourcePtr const &","Ogre::PatchMeshPtr", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ResourcePtr const &","Ogre::PatchMeshPtr", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ResourcePtr * >(argp1);
  result = (Ogre::PatchMeshPtr *)new Ogre::PatchMeshPtr((Ogre::ResourcePtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_PatchMeshPtr(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_PatchMeshPtr__SWIG_0(nargs, args, self);
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PatchMeshPtr__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PatchMeshPtr, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PatchMeshPtr__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_PatchMeshPtr__SWIG_3(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "PatchMeshPtr.new", 
    "    PatchMeshPtr.new()\n"
    "    PatchMeshPtr.new(Ogre::PatchMesh *rep)\n"
    "    PatchMeshPtr.new(Ogre::PatchMeshPtr const &r)\n"
    "    PatchMeshPtr.new(Ogre::ResourcePtr const &r)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_PatchMeshPtr(Ogre::PatchMeshPtr *arg1) {
    delete arg1;
}

swig_class SwigClassMeshManager;

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

SWIGINTERN VALUE
_wrap_new_MeshManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MeshManager";
  Ogre::MeshManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MeshManager *)new Ogre::MeshManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MeshManager(Ogre::MeshManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MeshManager__initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","_initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  (arg1)->_initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_createOrRetrieve__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::HardwareBuffer::Usage arg7 ;
  Ogre::HardwareBuffer::Usage arg8 ;
  bool arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::HardwareBuffer::Usage >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::HardwareBuffer::Usage >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::HardwareBuffer::Usage arg7 ;
  Ogre::HardwareBuffer::Usage arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::HardwareBuffer::Usage >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::HardwareBuffer::Usage >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::HardwareBuffer::Usage arg7 ;
  Ogre::HardwareBuffer::Usage arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::HardwareBuffer::Usage >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createOrRetrieve", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::HardwareBuffer::Usage >(val8);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  Ogre::HardwareBuffer::Usage arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createOrRetrieve", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::HardwareBuffer::Usage >(val7);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createOrRetrieve", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::ManualResourceLoader *arg5 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > result;
  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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createOrRetrieve", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp5);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOrRetrieve", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > > 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createOrRetrieve", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createOrRetrieve", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 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 &","createOrRetrieve", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOrRetrieve", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->createOrRetrieve((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ResourceManager::ResourceCreateOrRetrieveResult(static_cast< const Ogre::ResourceManager::ResourceCreateOrRetrieveResult& >(result))), SWIGTYPE_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 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_MeshManager_createOrRetrieve(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[11];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 11) 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_Ogre__MeshManager, 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_MeshManager_createOrRetrieve__SWIG_7(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshManager_createOrRetrieve__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_MeshManager_createOrRetrieve__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_MeshManager_createOrRetrieve__SWIG_4(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshManager_createOrRetrieve__SWIG_3(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_MeshManager_createOrRetrieve__SWIG_2(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_MeshManager_createOrRetrieve__SWIG_1(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_MeshManager_createOrRetrieve__SWIG_0(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "MeshManager.createOrRetrieve", 
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *params, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexBufferShadowed, bool indexBufferShadowed)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *params, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexBufferShadowed)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *params, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *params, Ogre::HardwareBuffer::Usage vertexBufferUsage)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *params)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::ResourceManager::ResourceCreateOrRetrieveResult MeshManager.createOrRetrieve(Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  Ogre::HardwareBuffer::Usage arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::HardwareBuffer::Usage >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","prepare", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","prepare", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
  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_MeshManager_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  Ogre::HardwareBuffer::Usage arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::HardwareBuffer::Usage >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","prepare", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  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_MeshManager_prepare__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  Ogre::HardwareBuffer::Usage arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::MeshPtr result;
  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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::HardwareBuffer::Usage >(val5);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  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_MeshManager_prepare__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::MeshPtr 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","prepare", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  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_MeshManager_prepare__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  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_MeshManager_prepare(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__MeshManager, 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_MeshManager_prepare__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshManager_prepare__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            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_MeshManager_prepare__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            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_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_MeshManager_prepare__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            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_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshManager_prepare__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "MeshManager.prepare", 
    "    Ogre::MeshPtr MeshManager.prepare(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexBufferShadowed, bool indexBufferShadowed)\n"
    "    Ogre::MeshPtr MeshManager.prepare(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexBufferShadowed)\n"
    "    Ogre::MeshPtr MeshManager.prepare(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.prepare(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.prepare(Ogre::String const &filename, Ogre::String const &groupName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  Ogre::HardwareBuffer::Usage arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","load", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::HardwareBuffer::Usage >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","load", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","load", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
  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_MeshManager_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  Ogre::HardwareBuffer::Usage arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","load", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::HardwareBuffer::Usage >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","load", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  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_MeshManager_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  Ogre::HardwareBuffer::Usage arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  Ogre::MeshPtr result;
  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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","load", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::HardwareBuffer::Usage >(val5);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  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_MeshManager_load__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::HardwareBuffer::Usage arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::MeshPtr 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","load", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::HardwareBuffer::Usage >(val4);
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  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_MeshManager_load__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  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_MeshManager_load(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__MeshManager, 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_MeshManager_load__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshManager_load__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            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_MeshManager_load__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            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_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_MeshManager_load__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          {
            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_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshManager_load__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "MeshManager.load", 
    "    Ogre::MeshPtr MeshManager.load(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexBufferShadowed, bool indexBufferShadowed)\n"
    "    Ogre::MeshPtr MeshManager.load(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexBufferShadowed)\n"
    "    Ogre::MeshPtr MeshManager.load(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.load(Ogre::String const &filename, Ogre::String const &groupName, Ogre::HardwareBuffer::Usage vertexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.load(Ogre::String const &filename, Ogre::String const &groupName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_createManual__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::ManualResourceLoader *arg4 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::MeshPtr 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","createManual", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp4);
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  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_MeshManager_createManual__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createManual", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createManual", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 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 &","createManual", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManual", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->createManual((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  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_MeshManager_createManual(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_Ogre__MeshManager, 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_MeshManager_createManual__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_MeshManager_createManual__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "MeshManager.createManual", 
    "    Ogre::MeshPtr MeshManager.createManual(Ogre::String const &name, Ogre::String const &groupName, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::MeshPtr MeshManager.createManual(Ogre::String const &name, Ogre::String const &groupName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_createPlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  Ogre::Real arg11 ;
  Ogre::Real arg12 ;
  Ogre::Vector3 *arg13 = 0 ;
  Ogre::HardwareBuffer::Usage arg14 ;
  Ogre::HardwareBuffer::Usage arg15 ;
  bool arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 16) || (argc > 16)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 16)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  ecode11 = SWIG_AsVal_float(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  res13 = SWIG_ConvertPtr(argv[11], &argp13, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createPlane", 13, argv[11] )); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createPlane", 13, argv[11])); 
  }
  arg13 = reinterpret_cast< Ogre::Vector3 * >(argp13);
  ecode14 = SWIG_AsVal_int(argv[12], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createPlane", 14, argv[12] ));
  } 
  arg14 = static_cast< Ogre::HardwareBuffer::Usage >(val14);
  ecode15 = SWIG_AsVal_int(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createPlane", 15, argv[13] ));
  } 
  arg15 = static_cast< Ogre::HardwareBuffer::Usage >(val15);
  ecode16 = SWIG_AsVal_bool(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "bool","createPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< bool >(val16);
  ecode17 = SWIG_AsVal_bool(argv[15], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "bool","createPlane", 17, argv[15] ));
  } 
  arg17 = static_cast< bool >(val17);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(Ogre::Vector3 const &)*arg13,arg14,arg15,arg16,arg17);
  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_MeshManager_createPlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  Ogre::Real arg11 ;
  Ogre::Real arg12 ;
  Ogre::Vector3 *arg13 = 0 ;
  Ogre::HardwareBuffer::Usage arg14 ;
  Ogre::HardwareBuffer::Usage arg15 ;
  bool arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  bool val16 ;
  int ecode16 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 15) || (argc > 15)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 15)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  ecode11 = SWIG_AsVal_float(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  res13 = SWIG_ConvertPtr(argv[11], &argp13, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createPlane", 13, argv[11] )); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createPlane", 13, argv[11])); 
  }
  arg13 = reinterpret_cast< Ogre::Vector3 * >(argp13);
  ecode14 = SWIG_AsVal_int(argv[12], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createPlane", 14, argv[12] ));
  } 
  arg14 = static_cast< Ogre::HardwareBuffer::Usage >(val14);
  ecode15 = SWIG_AsVal_int(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createPlane", 15, argv[13] ));
  } 
  arg15 = static_cast< Ogre::HardwareBuffer::Usage >(val15);
  ecode16 = SWIG_AsVal_bool(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "bool","createPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< bool >(val16);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(Ogre::Vector3 const &)*arg13,arg14,arg15,arg16);
  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_MeshManager_createPlane__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  Ogre::Real arg11 ;
  Ogre::Real arg12 ;
  Ogre::Vector3 *arg13 = 0 ;
  Ogre::HardwareBuffer::Usage arg14 ;
  Ogre::HardwareBuffer::Usage arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 14) || (argc > 14)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 14)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  ecode11 = SWIG_AsVal_float(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  res13 = SWIG_ConvertPtr(argv[11], &argp13, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createPlane", 13, argv[11] )); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createPlane", 13, argv[11])); 
  }
  arg13 = reinterpret_cast< Ogre::Vector3 * >(argp13);
  ecode14 = SWIG_AsVal_int(argv[12], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createPlane", 14, argv[12] ));
  } 
  arg14 = static_cast< Ogre::HardwareBuffer::Usage >(val14);
  ecode15 = SWIG_AsVal_int(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createPlane", 15, argv[13] ));
  } 
  arg15 = static_cast< Ogre::HardwareBuffer::Usage >(val15);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(Ogre::Vector3 const &)*arg13,arg14,arg15);
  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_MeshManager_createPlane__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  Ogre::Real arg11 ;
  Ogre::Real arg12 ;
  Ogre::Vector3 *arg13 = 0 ;
  Ogre::HardwareBuffer::Usage arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  int val14 ;
  int ecode14 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 13) || (argc > 13)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 13)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  ecode11 = SWIG_AsVal_float(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  res13 = SWIG_ConvertPtr(argv[11], &argp13, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createPlane", 13, argv[11] )); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createPlane", 13, argv[11])); 
  }
  arg13 = reinterpret_cast< Ogre::Vector3 * >(argp13);
  ecode14 = SWIG_AsVal_int(argv[12], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createPlane", 14, argv[12] ));
  } 
  arg14 = static_cast< Ogre::HardwareBuffer::Usage >(val14);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(Ogre::Vector3 const &)*arg13,arg14);
  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_MeshManager_createPlane__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  Ogre::Real arg11 ;
  Ogre::Real arg12 ;
  Ogre::Vector3 *arg13 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  void *argp13 ;
  int res13 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 12) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  ecode11 = SWIG_AsVal_float(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  res13 = SWIG_ConvertPtr(argv[11], &argp13, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res13)) {
    SWIG_exception_fail(SWIG_ArgError(res13), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createPlane", 13, argv[11] )); 
  }
  if (!argp13) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createPlane", 13, argv[11])); 
  }
  arg13 = reinterpret_cast< Ogre::Vector3 * >(argp13);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,(Ogre::Vector3 const &)*arg13);
  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_MeshManager_createPlane__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  Ogre::Real arg11 ;
  Ogre::Real arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  ecode11 = SWIG_AsVal_float(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  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_MeshManager_createPlane__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  Ogre::Real arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  float val11 ;
  int ecode11 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  ecode11 = SWIG_AsVal_float(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::Real >(val11);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  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_MeshManager_createPlane__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  unsigned short arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  unsigned short val10 ;
  int ecode10 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  ecode10 = SWIG_AsVal_unsigned_SS_short(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "unsigned short","createPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< unsigned short >(val10);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  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_MeshManager_createPlane__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","createPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  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_MeshManager_createPlane__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8);
  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_MeshManager_createPlane__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  int arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "int","createPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< int >(val7);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7);
  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_MeshManager_createPlane__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 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 &","createPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->createPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6);
  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_MeshManager_createPlane(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[18];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 18) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_MeshManager_createPlane__SWIG_11(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshManager_createPlane__SWIG_10(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_MeshManager_createPlane__SWIG_9(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_MeshManager_createPlane__SWIG_8(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_MeshManager_createPlane__SWIG_7(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_MeshManager_createPlane__SWIG_6(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_MeshManager_createPlane__SWIG_5(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              return _wrap_MeshManager_createPlane__SWIG_4(nargs, args, self);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_MeshManager_createPlane__SWIG_3(nargs, args, self);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_MeshManager_createPlane__SWIG_2(nargs, args, self);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_MeshManager_createPlane__SWIG_1(nargs, args, self);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_unsigned_SS_short(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_float(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            void *vptr = 0;
                            int res = SWIG_ConvertPtr(argv[12], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                            _v = SWIG_CheckState(res);
                            if (_v) {
                              {
                                int res = SWIG_AsVal_int(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_bool(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_MeshManager_createPlane__SWIG_0(nargs, args, self);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 18, "MeshManager.createPlane", 
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexShadowBuffer, bool indexShadowBuffer)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexShadowBuffer)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments, bool normals)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments, int ysegments)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, int xsegments)\n"
    "    Ogre::MeshPtr MeshManager.createPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_createCurvedIllusionPlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::Quaternion *arg15 = 0 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  Ogre::HardwareBuffer::Usage arg17 ;
  bool arg18 ;
  bool arg19 ;
  int arg20 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  int val20 ;
  int ecode20 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 19) || (argc > 19)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 19)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  res15 = SWIG_ConvertPtr(argv[13], &argp15, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13] )); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13])); 
  }
  arg15 = reinterpret_cast< Ogre::Quaternion * >(argp15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  ecode17 = SWIG_AsVal_int(argv[15], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 17, argv[15] ));
  } 
  arg17 = static_cast< Ogre::HardwareBuffer::Usage >(val17);
  ecode18 = SWIG_AsVal_bool(argv[16], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 18, argv[16] ));
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_bool(argv[17], &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 19, argv[17] ));
  } 
  arg19 = static_cast< bool >(val19);
  ecode20 = SWIG_AsVal_int(argv[18], &val20);
  if (!SWIG_IsOK(ecode20)) {
    SWIG_exception_fail(SWIG_ArgError(ecode20), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 20, argv[18] ));
  } 
  arg20 = static_cast< int >(val20);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,(Ogre::Quaternion const &)*arg15,arg16,arg17,arg18,arg19,arg20);
  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_MeshManager_createCurvedIllusionPlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::Quaternion *arg15 = 0 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  Ogre::HardwareBuffer::Usage arg17 ;
  bool arg18 ;
  bool arg19 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  bool val19 ;
  int ecode19 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 18) || (argc > 18)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 18)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  res15 = SWIG_ConvertPtr(argv[13], &argp15, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13] )); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13])); 
  }
  arg15 = reinterpret_cast< Ogre::Quaternion * >(argp15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  ecode17 = SWIG_AsVal_int(argv[15], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 17, argv[15] ));
  } 
  arg17 = static_cast< Ogre::HardwareBuffer::Usage >(val17);
  ecode18 = SWIG_AsVal_bool(argv[16], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 18, argv[16] ));
  } 
  arg18 = static_cast< bool >(val18);
  ecode19 = SWIG_AsVal_bool(argv[17], &val19);
  if (!SWIG_IsOK(ecode19)) {
    SWIG_exception_fail(SWIG_ArgError(ecode19), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 19, argv[17] ));
  } 
  arg19 = static_cast< bool >(val19);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,(Ogre::Quaternion const &)*arg15,arg16,arg17,arg18,arg19);
  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_MeshManager_createCurvedIllusionPlane__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::Quaternion *arg15 = 0 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  Ogre::HardwareBuffer::Usage arg17 ;
  bool arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 17) || (argc > 17)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 17)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  res15 = SWIG_ConvertPtr(argv[13], &argp15, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13] )); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13])); 
  }
  arg15 = reinterpret_cast< Ogre::Quaternion * >(argp15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  ecode17 = SWIG_AsVal_int(argv[15], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 17, argv[15] ));
  } 
  arg17 = static_cast< Ogre::HardwareBuffer::Usage >(val17);
  ecode18 = SWIG_AsVal_bool(argv[16], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 18, argv[16] ));
  } 
  arg18 = static_cast< bool >(val18);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,(Ogre::Quaternion const &)*arg15,arg16,arg17,arg18);
  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_MeshManager_createCurvedIllusionPlane__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::Quaternion *arg15 = 0 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  Ogre::HardwareBuffer::Usage arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  int val17 ;
  int ecode17 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 16) || (argc > 16)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 16)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  res15 = SWIG_ConvertPtr(argv[13], &argp15, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13] )); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13])); 
  }
  arg15 = reinterpret_cast< Ogre::Quaternion * >(argp15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  ecode17 = SWIG_AsVal_int(argv[15], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 17, argv[15] ));
  } 
  arg17 = static_cast< Ogre::HardwareBuffer::Usage >(val17);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,(Ogre::Quaternion const &)*arg15,arg16,arg17);
  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_MeshManager_createCurvedIllusionPlane__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::Quaternion *arg15 = 0 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 15) || (argc > 15)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 15)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  res15 = SWIG_ConvertPtr(argv[13], &argp15, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13] )); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13])); 
  }
  arg15 = reinterpret_cast< Ogre::Quaternion * >(argp15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedIllusionPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,(Ogre::Quaternion const &)*arg15,arg16);
  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_MeshManager_createCurvedIllusionPlane__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::Quaternion *arg15 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  void *argp15 ;
  int res15 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 14) || (argc > 14)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 14)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  res15 = SWIG_ConvertPtr(argv[13], &argp15, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res15)) {
    SWIG_exception_fail(SWIG_ArgError(res15), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13] )); 
  }
  if (!argp15) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createCurvedIllusionPlane", 15, argv[13])); 
  }
  arg15 = reinterpret_cast< Ogre::Quaternion * >(argp15);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,(Ogre::Quaternion const &)*arg15);
  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_MeshManager_createCurvedIllusionPlane__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 13) || (argc > 13)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 13)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedIllusionPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14);
  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_MeshManager_createCurvedIllusionPlane__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 12) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  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_MeshManager_createCurvedIllusionPlane__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  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_MeshManager_createCurvedIllusionPlane__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedIllusionPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  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_MeshManager_createCurvedIllusionPlane__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedIllusionPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  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_MeshManager_createCurvedIllusionPlane__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  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_MeshManager_createCurvedIllusionPlane__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedIllusionPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8);
  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_MeshManager_createCurvedIllusionPlane__SWIG_13(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedIllusionPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedIllusionPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 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 &","createCurvedIllusionPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedIllusionPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedIllusionPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedIllusionPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  result = (arg1)->createCurvedIllusionPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7);
  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_MeshManager_createCurvedIllusionPlane(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[21];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 21) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_13(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_12(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_11(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_10(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_9(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_8(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_7(nargs, args, self);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_6(nargs, args, self);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_5(nargs, args, self);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_4(nargs, args, self);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_3(nargs, args, self);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_2(nargs, args, self);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 19) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_1(nargs, args, self);
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 20) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                void *vptr = 0;
                                int res = SWIG_ConvertPtr(argv[14], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                                _v = SWIG_CheckState(res);
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_int(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        {
                                          int res = SWIG_AsVal_bool(argv[18], NULL);
                                          _v = SWIG_CheckState(res);
                                        }
                                        if (_v) {
                                          {
                                            int res = SWIG_AsVal_int(argv[19], NULL);
                                            _v = SWIG_CheckState(res);
                                          }
                                          if (_v) {
                                            return _wrap_MeshManager_createCurvedIllusionPlane__SWIG_0(nargs, args, self);
                                          }
                                        }
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 21, "MeshManager.createCurvedIllusionPlane", 
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::Quaternion const &orientation, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexShadowBuffer, bool indexShadowBuffer, int ySegmentsToKeep)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::Quaternion const &orientation, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexShadowBuffer, bool indexShadowBuffer)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::Quaternion const &orientation, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexShadowBuffer)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::Quaternion const &orientation, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::Quaternion const &orientation, Ogre::HardwareBuffer::Usage vertexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector, Ogre::Quaternion const &orientation)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile, Ogre::Vector3 const &upVector)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile, Ogre::Real vTile)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real uTile)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments, bool normals)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments, int ysegments)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature, int xsegments)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedIllusionPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real curvature)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_createCurvedPlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::HardwareBuffer::Usage arg15 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  bool arg17 ;
  bool arg18 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  bool val18 ;
  int ecode18 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 17) || (argc > 17)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 17)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  ecode15 = SWIG_AsVal_int(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedPlane", 15, argv[13] ));
  } 
  arg15 = static_cast< Ogre::HardwareBuffer::Usage >(val15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  ecode17 = SWIG_AsVal_bool(argv[15], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 17, argv[15] ));
  } 
  arg17 = static_cast< bool >(val17);
  ecode18 = SWIG_AsVal_bool(argv[16], &val18);
  if (!SWIG_IsOK(ecode18)) {
    SWIG_exception_fail(SWIG_ArgError(ecode18), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 18, argv[16] ));
  } 
  arg18 = static_cast< bool >(val18);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,arg15,arg16,arg17,arg18);
  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_MeshManager_createCurvedPlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::HardwareBuffer::Usage arg15 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  bool arg17 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  bool val17 ;
  int ecode17 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 16) || (argc > 16)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 16)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  ecode15 = SWIG_AsVal_int(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedPlane", 15, argv[13] ));
  } 
  arg15 = static_cast< Ogre::HardwareBuffer::Usage >(val15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  ecode17 = SWIG_AsVal_bool(argv[15], &val17);
  if (!SWIG_IsOK(ecode17)) {
    SWIG_exception_fail(SWIG_ArgError(ecode17), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 17, argv[15] ));
  } 
  arg17 = static_cast< bool >(val17);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,arg15,arg16,arg17);
  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_MeshManager_createCurvedPlane__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::HardwareBuffer::Usage arg15 ;
  Ogre::HardwareBuffer::Usage arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  int val16 ;
  int ecode16 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 15) || (argc > 15)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 15)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  ecode15 = SWIG_AsVal_int(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedPlane", 15, argv[13] ));
  } 
  arg15 = static_cast< Ogre::HardwareBuffer::Usage >(val15);
  ecode16 = SWIG_AsVal_int(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedPlane", 16, argv[14] ));
  } 
  arg16 = static_cast< Ogre::HardwareBuffer::Usage >(val16);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,arg15,arg16);
  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_MeshManager_createCurvedPlane__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  Ogre::HardwareBuffer::Usage arg15 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  int val15 ;
  int ecode15 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 14) || (argc > 14)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 14)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  ecode15 = SWIG_AsVal_int(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createCurvedPlane", 15, argv[13] ));
  } 
  arg15 = static_cast< Ogre::HardwareBuffer::Usage >(val15);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14,arg15);
  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_MeshManager_createCurvedPlane__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  Ogre::Vector3 *arg14 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  void *argp14 ;
  int res14 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 13) || (argc > 13)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 13)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  res14 = SWIG_ConvertPtr(argv[12], &argp14, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res14)) {
    SWIG_exception_fail(SWIG_ArgError(res14), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12] )); 
  }
  if (!argp14) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createCurvedPlane", 14, argv[12])); 
  }
  arg14 = reinterpret_cast< Ogre::Vector3 * >(argp14);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,(Ogre::Vector3 const &)*arg14);
  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_MeshManager_createCurvedPlane__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  Ogre::Real arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  float val13 ;
  int ecode13 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 12) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  ecode13 = SWIG_AsVal_float(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 13, argv[11] ));
  } 
  arg13 = static_cast< Ogre::Real >(val13);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  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_MeshManager_createCurvedPlane__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  Ogre::Real arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  float val12 ;
  int ecode12 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  ecode12 = SWIG_AsVal_float(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::Real >(val12);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  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_MeshManager_createCurvedPlane__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  unsigned short arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  unsigned short val11 ;
  int ecode11 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  ecode11 = SWIG_AsVal_unsigned_SS_short(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "unsigned short","createCurvedPlane", 11, argv[9] ));
  } 
  arg11 = static_cast< unsigned short >(val11);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  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_MeshManager_createCurvedPlane__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","createCurvedPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  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_MeshManager_createCurvedPlane__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","createCurvedPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  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_MeshManager_createCurvedPlane__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  int arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "int","createCurvedPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< int >(val8);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7,arg8);
  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_MeshManager_createCurvedPlane__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6,arg7);
  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_MeshManager_createCurvedPlane__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Plane *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  Ogre::MeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createCurvedPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createCurvedPlane", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 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 &","createCurvedPlane", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCurvedPlane", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Plane const &","createCurvedPlane", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","createCurvedPlane", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Plane * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","createCurvedPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  result = (arg1)->createCurvedPlane((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::Plane const &)*arg4,arg5,arg6);
  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_MeshManager_createCurvedPlane(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[19];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 19) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_MeshManager_createCurvedPlane__SWIG_12(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshManager_createCurvedPlane__SWIG_11(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_MeshManager_createCurvedPlane__SWIG_10(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_MeshManager_createCurvedPlane__SWIG_9(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_MeshManager_createCurvedPlane__SWIG_8(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_MeshManager_createCurvedPlane__SWIG_7(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_MeshManager_createCurvedPlane__SWIG_6(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_MeshManager_createCurvedPlane__SWIG_5(nargs, args, self);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                return _wrap_MeshManager_createCurvedPlane__SWIG_4(nargs, args, self);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 15) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  return _wrap_MeshManager_createCurvedPlane__SWIG_3(nargs, args, self);
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 16) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    return _wrap_MeshManager_createCurvedPlane__SWIG_2(nargs, args, self);
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 17) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      return _wrap_MeshManager_createCurvedPlane__SWIG_1(nargs, args, self);
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 18) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_bool(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_unsigned_SS_short(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_float(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_float(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              void *vptr = 0;
                              int res = SWIG_ConvertPtr(argv[13], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
                              _v = SWIG_CheckState(res);
                              if (_v) {
                                {
                                  int res = SWIG_AsVal_int(argv[14], NULL);
                                  _v = SWIG_CheckState(res);
                                }
                                if (_v) {
                                  {
                                    int res = SWIG_AsVal_int(argv[15], NULL);
                                    _v = SWIG_CheckState(res);
                                  }
                                  if (_v) {
                                    {
                                      int res = SWIG_AsVal_bool(argv[16], NULL);
                                      _v = SWIG_CheckState(res);
                                    }
                                    if (_v) {
                                      {
                                        int res = SWIG_AsVal_bool(argv[17], NULL);
                                        _v = SWIG_CheckState(res);
                                      }
                                      if (_v) {
                                        return _wrap_MeshManager_createCurvedPlane__SWIG_0(nargs, args, self);
                                      }
                                    }
                                  }
                                }
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 19, "MeshManager.createCurvedPlane", 
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real xTile, Ogre::Real yTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexShadowBuffer, bool indexShadowBuffer)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real xTile, Ogre::Real yTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage, bool vertexShadowBuffer)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real xTile, Ogre::Real yTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage, Ogre::HardwareBuffer::Usage indexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real xTile, Ogre::Real yTile, Ogre::Vector3 const &upVector, Ogre::HardwareBuffer::Usage vertexBufferUsage)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real xTile, Ogre::Real yTile, Ogre::Vector3 const &upVector)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real xTile, Ogre::Real yTile)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets, Ogre::Real xTile)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals, unsigned short numTexCoordSets)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments, bool normals)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments, int ysegments)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow, int xsegments)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height, Ogre::Real bow)\n"
    "    Ogre::MeshPtr MeshManager.createCurvedPlane(Ogre::String const &name, Ogre::String const &groupName, Ogre::Plane const &plane, Ogre::Real width, Ogre::Real height)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_createBezierPatch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  Ogre::PatchSurface::VisibleSide arg10 ;
  Ogre::HardwareBuffer::Usage arg11 ;
  Ogre::HardwareBuffer::Usage arg12 ;
  bool arg13 ;
  bool arg14 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  bool val14 ;
  int ecode14 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 13) || (argc > 13)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 13)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","createBezierPatch", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::PatchSurface::VisibleSide >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createBezierPatch", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::HardwareBuffer::Usage >(val11);
  ecode12 = SWIG_AsVal_int(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createBezierPatch", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::HardwareBuffer::Usage >(val12);
  ecode13 = SWIG_AsVal_bool(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "bool","createBezierPatch", 13, argv[11] ));
  } 
  arg13 = static_cast< bool >(val13);
  ecode14 = SWIG_AsVal_bool(argv[12], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "bool","createBezierPatch", 14, argv[12] ));
  } 
  arg14 = static_cast< bool >(val14);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13,arg14);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  Ogre::PatchSurface::VisibleSide arg10 ;
  Ogre::HardwareBuffer::Usage arg11 ;
  Ogre::HardwareBuffer::Usage arg12 ;
  bool arg13 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  bool val13 ;
  int ecode13 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 12) || (argc > 12)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 12)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","createBezierPatch", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::PatchSurface::VisibleSide >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createBezierPatch", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::HardwareBuffer::Usage >(val11);
  ecode12 = SWIG_AsVal_int(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createBezierPatch", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::HardwareBuffer::Usage >(val12);
  ecode13 = SWIG_AsVal_bool(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "bool","createBezierPatch", 13, argv[11] ));
  } 
  arg13 = static_cast< bool >(val13);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12,arg13);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  Ogre::PatchSurface::VisibleSide arg10 ;
  Ogre::HardwareBuffer::Usage arg11 ;
  Ogre::HardwareBuffer::Usage arg12 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int val12 ;
  int ecode12 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","createBezierPatch", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::PatchSurface::VisibleSide >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createBezierPatch", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::HardwareBuffer::Usage >(val11);
  ecode12 = SWIG_AsVal_int(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createBezierPatch", 12, argv[10] ));
  } 
  arg12 = static_cast< Ogre::HardwareBuffer::Usage >(val12);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11,arg12);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  Ogre::PatchSurface::VisibleSide arg10 ;
  Ogre::HardwareBuffer::Usage arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","createBezierPatch", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::PatchSurface::VisibleSide >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "Ogre::HardwareBuffer::Usage","createBezierPatch", 11, argv[9] ));
  } 
  arg11 = static_cast< Ogre::HardwareBuffer::Usage >(val11);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10,arg11);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  Ogre::PatchSurface::VisibleSide arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "Ogre::PatchSurface::VisibleSide","createBezierPatch", 10, argv[8] ));
  } 
  arg10 = static_cast< Ogre::PatchSurface::VisibleSide >(val10);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *arg4 = (void *) 0 ;
  Ogre::VertexDeclaration *arg5 = (Ogre::VertexDeclaration *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  Ogre::PatchMeshPtr result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","createBezierPatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(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( "", "Ogre::String const &","createBezierPatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 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 &","createBezierPatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBezierPatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","createBezierPatch", 4, argv[2] )); 
  }
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__VertexDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::VertexDeclaration *","createBezierPatch", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::VertexDeclaration * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","createBezierPatch", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  result = (arg1)->createBezierPatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj((new Ogre::PatchMeshPtr(static_cast< const Ogre::PatchMeshPtr& >(result))), SWIGTYPE_p_Ogre__PatchMeshPtr, 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_MeshManager_createBezierPatch(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[15];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 15) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_MeshManager_createBezierPatch__SWIG_7(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_MeshManager_createBezierPatch__SWIG_6(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_MeshManager_createBezierPatch__SWIG_5(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_MeshManager_createBezierPatch__SWIG_4(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_MeshManager_createBezierPatch__SWIG_3(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            return _wrap_MeshManager_createBezierPatch__SWIG_2(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 13) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              return _wrap_MeshManager_createBezierPatch__SWIG_1(nargs, args, self);
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 14) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshManager, 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) {
          void *ptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &ptr, 0, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__VertexDeclaration, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_size_t(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_size_t(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_size_t(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          {
                            int res = SWIG_AsVal_int(argv[11], NULL);
                            _v = SWIG_CheckState(res);
                          }
                          if (_v) {
                            {
                              int res = SWIG_AsVal_bool(argv[12], NULL);
                              _v = SWIG_CheckState(res);
                            }
                            if (_v) {
                              {
                                int res = SWIG_AsVal_bool(argv[13], NULL);
                                _v = SWIG_CheckState(res);
                              }
                              if (_v) {
                                return _wrap_MeshManager_createBezierPatch__SWIG_0(nargs, args, self);
                              }
                            }
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 15, "MeshManager.createBezierPatch", 
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage, Ogre::HardwareBuffer::Usage ibUsage, bool vbUseShadow, bool ibUseShadow)\n"
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage, Ogre::HardwareBuffer::Usage ibUsage, bool vbUseShadow)\n"
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage, Ogre::HardwareBuffer::Usage ibUsage)\n"
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide, Ogre::HardwareBuffer::Usage vbUsage)\n"
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel, Ogre::PatchSurface::VisibleSide visibleSide)\n"
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel, size_t vMaxSubdivisionLevel)\n"
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height, size_t uMaxSubdivisionLevel)\n"
    "    Ogre::PatchMeshPtr MeshManager.createBezierPatch(Ogre::String const &name, Ogre::String const &groupName, void *controlPointBuffer, Ogre::VertexDeclaration *declaration, size_t width, size_t height)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_setPrepareAllMeshesForShadowVolumes(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","setPrepareAllMeshesForShadowVolumes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPrepareAllMeshesForShadowVolumes", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPrepareAllMeshesForShadowVolumes(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_getPrepareAllMeshesForShadowVolumes(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","getPrepareAllMeshesForShadowVolumes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  result = (bool)(arg1)->getPrepareAllMeshesForShadowVolumes();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MeshManager *) &Ogre::MeshManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MeshManager *)Ogre::MeshManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_getBoundsPaddingFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","getBoundsPaddingFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  result = (Ogre::Real)(arg1)->getBoundsPaddingFactor();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_setBoundsPaddingFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","setBoundsPaddingFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setBoundsPaddingFactor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setBoundsPaddingFactor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_setListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::MeshSerializerListener *arg2 = (Ogre::MeshSerializerListener *) 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","setListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MeshSerializerListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshSerializerListener *","setListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MeshSerializerListener * >(argp2);
  (arg1)->setListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_getListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshSerializerListener *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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","getListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  result = (Ogre::MeshSerializerListener *)(arg1)->getListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshSerializerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshManager_loadResource(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshManager *arg1 = (Ogre::MeshManager *) 0 ;
  Ogre::Resource *arg2 = (Ogre::Resource *) 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_Ogre__MeshManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshManager *","loadResource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource *","loadResource", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource * >(argp2);
  (arg1)->loadResource(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassMeshSerializer;

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

SWIGINTERN VALUE
_wrap_new_MeshSerializer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MeshSerializer";
  Ogre::MeshSerializer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MeshSerializer *)new Ogre::MeshSerializer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MeshSerializer(Ogre::MeshSerializer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Serializer::Endian arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    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 &","exportMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportMesh", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Serializer::Endian >(val4);
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    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 &","exportMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::MeshVersion arg4 ;
  Ogre::Serializer::Endian arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    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 &","exportMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::MeshVersion","exportMesh", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::MeshVersion >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportMesh", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Serializer::Endian >(val5);
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3,arg4,arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::MeshVersion arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    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 &","exportMesh", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportMesh", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::MeshVersion","exportMesh", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::MeshVersion >(val4);
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  Ogre::Serializer::Endian arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportMesh", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportMesh", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportMesh", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Serializer::Endian >(val4);
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportMesh", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportMesh", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  Ogre::MeshVersion arg4 ;
  Ogre::Serializer::Endian arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportMesh", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportMesh", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::MeshVersion","exportMesh", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::MeshVersion >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportMesh", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Serializer::Endian >(val5);
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_exportMesh__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  Ogre::MeshVersion arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","exportMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh const *","exportMesh", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportMesh", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportMesh", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::MeshVersion","exportMesh", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::MeshVersion >(val4);
  (arg1)->exportMesh((Ogre::Mesh const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_MeshSerializer_exportMesh(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_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_MeshSerializer_exportMesh__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 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_MeshSerializer_exportMesh__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshSerializer_exportMesh__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshSerializer_exportMesh__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshSerializer_exportMesh__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_MeshSerializer_exportMesh__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _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_MeshSerializer_exportMesh__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__MeshSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Mesh, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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_MeshSerializer_exportMesh__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "MeshSerializer.exportMesh", 
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::String const &filename, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::String const &filename)\n"
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::String const &filename, Ogre::MeshVersion version, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::String const &filename, Ogre::MeshVersion version)\n"
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream)\n"
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream, Ogre::MeshVersion version, Ogre::Serializer::Endian endianMode)\n"
    "    void MeshSerializer.exportMesh(Ogre::Mesh const *pMesh, Ogre::DataStreamPtr stream, Ogre::MeshVersion version)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_importMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::Mesh *arg3 = (Ogre::Mesh *) 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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","importMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","importMesh", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","importMesh", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Mesh *","importMesh", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Mesh * >(argp3);
  (arg1)->importMesh(*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_setListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  Ogre::MeshSerializerListener *arg2 = (Ogre::MeshSerializerListener *) 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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","setListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MeshSerializerListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshSerializerListener *","setListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MeshSerializerListener * >(argp2);
  (arg1)->setListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializer_getListener(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializer *arg1 = (Ogre::MeshSerializer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshSerializerListener *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_Ogre__MeshSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializer *","getListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializer * >(argp1);
  result = (Ogre::MeshSerializerListener *)(arg1)->getListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshSerializerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMeshSerializerListener;

SWIGINTERN void
free_Ogre_MeshSerializerListener(Ogre::MeshSerializerListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_MeshSerializerListener_processMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializerListener *arg1 = (Ogre::MeshSerializerListener *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg3 = (Ogre::String *) 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_Ogre__MeshSerializerListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializerListener *","processMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializerListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh *","processMaterialName", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String *","processMaterialName", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::String * >(argp3);
  (arg1)->processMaterialName(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MeshSerializerListener_processSkeletonName(int argc, VALUE *argv, VALUE self) {
  Ogre::MeshSerializerListener *arg1 = (Ogre::MeshSerializerListener *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 0 ;
  Ogre::String *arg3 = (Ogre::String *) 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_Ogre__MeshSerializerListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MeshSerializerListener *","processSkeletonName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MeshSerializerListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh *","processSkeletonName", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String *","processSkeletonName", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::String * >(argp3);
  (arg1)->processSkeletonName(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassOptimisedUtil;

SWIGINTERN void
free_Ogre_OptimisedUtil(Ogre::OptimisedUtil *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_OptimisedUtil_getImplementation(int argc, VALUE *argv, VALUE self) {
  Ogre::OptimisedUtil *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OptimisedUtil *)Ogre::OptimisedUtil::getImplementation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OptimisedUtil, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OptimisedUtil_softwareVertexSkinning(int argc, VALUE *argv, VALUE self) {
  Ogre::OptimisedUtil *arg1 = (Ogre::OptimisedUtil *) 0 ;
  float *arg2 = (float *) 0 ;
  float *arg3 = (float *) 0 ;
  float *arg4 = (float *) 0 ;
  float *arg5 = (float *) 0 ;
  float *arg6 = (float *) 0 ;
  unsigned char *arg7 = (unsigned char *) 0 ;
  Ogre::Matrix4 **arg8 = (Ogre::Matrix4 **) 0 ;
  size_t arg9 ;
  size_t arg10 ;
  size_t arg11 ;
  size_t arg12 ;
  size_t arg13 ;
  size_t arg14 ;
  size_t arg15 ;
  size_t arg16 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  size_t val10 ;
  int ecode10 = 0 ;
  size_t val11 ;
  int ecode11 = 0 ;
  size_t val12 ;
  int ecode12 = 0 ;
  size_t val13 ;
  int ecode13 = 0 ;
  size_t val14 ;
  int ecode14 = 0 ;
  size_t val15 ;
  int ecode15 = 0 ;
  size_t val16 ;
  int ecode16 = 0 ;
  
  if ((argc < 15) || (argc > 15)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 15)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__OptimisedUtil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OptimisedUtil *","softwareVertexSkinning", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OptimisedUtil * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float const *","softwareVertexSkinning", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float *","softwareVertexSkinning", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float const *","softwareVertexSkinning", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "float *","softwareVertexSkinning", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< float * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "float const *","softwareVertexSkinning", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< float * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "unsigned char const *","softwareVertexSkinning", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< unsigned char * >(argp7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8,SWIGTYPE_p_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *const *","softwareVertexSkinning", 8, argv[6] )); 
  }
  arg8 = reinterpret_cast< Ogre::Matrix4 ** >(argp8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  ecode10 = SWIG_AsVal_size_t(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 10, argv[8] ));
  } 
  arg10 = static_cast< size_t >(val10);
  ecode11 = SWIG_AsVal_size_t(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 11, argv[9] ));
  } 
  arg11 = static_cast< size_t >(val11);
  ecode12 = SWIG_AsVal_size_t(argv[10], &val12);
  if (!SWIG_IsOK(ecode12)) {
    SWIG_exception_fail(SWIG_ArgError(ecode12), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 12, argv[10] ));
  } 
  arg12 = static_cast< size_t >(val12);
  ecode13 = SWIG_AsVal_size_t(argv[11], &val13);
  if (!SWIG_IsOK(ecode13)) {
    SWIG_exception_fail(SWIG_ArgError(ecode13), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 13, argv[11] ));
  } 
  arg13 = static_cast< size_t >(val13);
  ecode14 = SWIG_AsVal_size_t(argv[12], &val14);
  if (!SWIG_IsOK(ecode14)) {
    SWIG_exception_fail(SWIG_ArgError(ecode14), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 14, argv[12] ));
  } 
  arg14 = static_cast< size_t >(val14);
  ecode15 = SWIG_AsVal_size_t(argv[13], &val15);
  if (!SWIG_IsOK(ecode15)) {
    SWIG_exception_fail(SWIG_ArgError(ecode15), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 15, argv[13] ));
  } 
  arg15 = static_cast< size_t >(val15);
  ecode16 = SWIG_AsVal_size_t(argv[14], &val16);
  if (!SWIG_IsOK(ecode16)) {
    SWIG_exception_fail(SWIG_ArgError(ecode16), Ruby_Format_TypeError( "", "size_t","softwareVertexSkinning", 16, argv[14] ));
  } 
  arg16 = static_cast< size_t >(val16);
  (arg1)->softwareVertexSkinning((float const *)arg2,arg3,(float const *)arg4,arg5,(float const *)arg6,(unsigned char const *)arg7,(Ogre::Matrix4 const *const *)arg8,arg9,arg10,arg11,arg12,arg13,arg14,arg15,arg16);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OptimisedUtil_softwareVertexMorph(int argc, VALUE *argv, VALUE self) {
  Ogre::OptimisedUtil *arg1 = (Ogre::OptimisedUtil *) 0 ;
  Ogre::Real arg2 ;
  float *arg3 = (float *) 0 ;
  float *arg4 = (float *) 0 ;
  float *arg5 = (float *) 0 ;
  size_t arg6 ;
  size_t arg7 ;
  size_t arg8 ;
  size_t arg9 ;
  bool arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  size_t val8 ;
  int ecode8 = 0 ;
  size_t val9 ;
  int ecode9 = 0 ;
  bool val10 ;
  int ecode10 = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__OptimisedUtil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OptimisedUtil *","softwareVertexMorph", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OptimisedUtil * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","softwareVertexMorph", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "float const *","softwareVertexMorph", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< float * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float const *","softwareVertexMorph", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "float *","softwareVertexMorph", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< float * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","softwareVertexMorph", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","softwareVertexMorph", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ecode8 = SWIG_AsVal_size_t(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "size_t","softwareVertexMorph", 8, argv[6] ));
  } 
  arg8 = static_cast< size_t >(val8);
  ecode9 = SWIG_AsVal_size_t(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "size_t","softwareVertexMorph", 9, argv[7] ));
  } 
  arg9 = static_cast< size_t >(val9);
  ecode10 = SWIG_AsVal_bool(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "bool","softwareVertexMorph", 10, argv[8] ));
  } 
  arg10 = static_cast< bool >(val10);
  (arg1)->softwareVertexMorph(arg2,(float const *)arg3,(float const *)arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OptimisedUtil_concatenateAffineMatrices(int argc, VALUE *argv, VALUE self) {
  Ogre::OptimisedUtil *arg1 = (Ogre::OptimisedUtil *) 0 ;
  Ogre::Matrix4 *arg2 = 0 ;
  Ogre::Matrix4 *arg3 = (Ogre::Matrix4 *) 0 ;
  Ogre::Matrix4 *arg4 = (Ogre::Matrix4 *) 0 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__OptimisedUtil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OptimisedUtil *","concatenateAffineMatrices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OptimisedUtil * >(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 &","concatenateAffineMatrices", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","concatenateAffineMatrices", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","concatenateAffineMatrices", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Matrix4 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","concatenateAffineMatrices", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Matrix4 * >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","concatenateAffineMatrices", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->concatenateAffineMatrices((Ogre::Matrix4 const &)*arg2,(Ogre::Matrix4 const *)arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OptimisedUtil_calculateFaceNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::OptimisedUtil *arg1 = (Ogre::OptimisedUtil *) 0 ;
  float *arg2 = (float *) 0 ;
  Ogre::EdgeData::Triangle *arg3 = (Ogre::EdgeData::Triangle *) 0 ;
  Ogre::Vector4 *arg4 = (Ogre::Vector4 *) 0 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__OptimisedUtil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OptimisedUtil *","calculateFaceNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OptimisedUtil * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "float const *","calculateFaceNormals", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< float * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__EdgeData__Triangle, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::EdgeData::Triangle const *","calculateFaceNormals", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::EdgeData::Triangle * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector4 *","calculateFaceNormals", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector4 * >(argp4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","calculateFaceNormals", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->calculateFaceNormals((float const *)arg2,(Ogre::EdgeData::Triangle const *)arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OptimisedUtil_calculateLightFacing(int argc, VALUE *argv, VALUE self) {
  Ogre::OptimisedUtil *arg1 = (Ogre::OptimisedUtil *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  Ogre::Vector4 *arg3 = (Ogre::Vector4 *) 0 ;
  char *arg4 = (char *) 0 ;
  size_t arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  char *buf4 = 0 ;
  int alloc4 = 0 ;
  size_t val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__OptimisedUtil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OptimisedUtil *","calculateLightFacing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OptimisedUtil * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","calculateLightFacing", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","calculateLightFacing", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","calculateLightFacing", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Vector4 * >(argp3);
  res4 = SWIG_AsCharPtrAndSize(argv[2], &buf4, NULL, &alloc4);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "char *","calculateLightFacing", 4, argv[2] ));
  }
  arg4 = reinterpret_cast< char * >(buf4);
  ecode5 = SWIG_AsVal_size_t(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "size_t","calculateLightFacing", 5, argv[3] ));
  } 
  arg5 = static_cast< size_t >(val5);
  (arg1)->calculateLightFacing((Ogre::Vector4 const &)*arg2,(Ogre::Vector4 const *)arg3,arg4,arg5);
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
fail:
  if (alloc4 == SWIG_NEWOBJ) delete[] buf4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OptimisedUtil_extrudeVertices(int argc, VALUE *argv, VALUE self) {
  Ogre::OptimisedUtil *arg1 = (Ogre::OptimisedUtil *) 0 ;
  Ogre::Vector4 *arg2 = 0 ;
  Ogre::Real arg3 ;
  float *arg4 = (float *) 0 ;
  float *arg5 = (float *) 0 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__OptimisedUtil, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OptimisedUtil *","extrudeVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OptimisedUtil * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Vector4,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const &","extrudeVertices", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector4 const &","extrudeVertices", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","extrudeVertices", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float const *","extrudeVertices", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "float *","extrudeVertices", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< float * >(argp5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","extrudeVertices", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  (arg1)->extrudeVertices((Ogre::Vector4 const &)*arg2,arg3,(float const *)arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassOverlay;

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

SWIGINTERN VALUE
_wrap_new_Overlay(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Overlay";
  Ogre::Overlay *result = 0 ;
  
  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 &","Ogre::Overlay", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Overlay", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Overlay *)new Ogre::Overlay((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_Overlay(Ogre::Overlay *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Overlay_getChild(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayContainer *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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","getChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(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( "", "Ogre::String const &","getChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayContainer *)(arg1)->getChild((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::String *) &((Ogre::Overlay const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_setZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::ushort arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","setZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ushort","setZOrder", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ushort >(val2);
  (arg1)->setZOrder(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getZOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getZOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::ushort)((Ogre::Overlay const *)arg1)->getZOrder();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (bool)((Ogre::Overlay const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_isInitialised(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","isInitialised", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (bool)((Ogre::Overlay const *)arg1)->isInitialised();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_show(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","show", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  (arg1)->show();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_hide(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","hide", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  (arg1)->hide();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_add2D(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::OverlayContainer *arg2 = (Ogre::OverlayContainer *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","add2D", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","add2D", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayContainer * >(argp2);
  (arg1)->add2D(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_remove2D(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::OverlayContainer *arg2 = (Ogre::OverlayContainer *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","remove2D", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayContainer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayContainer *","remove2D", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayContainer * >(argp2);
  (arg1)->remove2D(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_add3D(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","add3D", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode *","add3D", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  (arg1)->add3D(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_remove3D(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","remove3D", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode *","remove3D", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  (arg1)->remove3D(arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::Overlay.clear

  call-seq:
    clear

Clear Overlay contents.
*/
SWIGINTERN VALUE
_wrap_Overlay_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_setScroll(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","setScroll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setScroll", 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","setScroll", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setScroll(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getScrollX(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getScrollX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScrollX();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getScrollY(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getScrollY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScrollY();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_scroll(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","scroll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","scroll", 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","scroll", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->scroll(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_setRotate(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Radian *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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","setRotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(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 const &","setRotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setRotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setRotate((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getRotate(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getRotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::Radian *) &((Ogre::Overlay const *)arg1)->getRotate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_rotate(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Radian *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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","rotate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(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 const &","rotate", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","rotate", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->rotate((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_setScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","setScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(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);
  (arg1)->setScale(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getScaleX(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getScaleX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScaleX();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getScaleY(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getScaleY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::Real)((Ogre::Overlay const *)arg1)->getScaleY();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay__getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","_getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","_getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::Overlay const *)arg1)->_getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay__findVisibleObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::RenderQueue *arg3 = (Ogre::RenderQueue *) 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","_findVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_findVisibleObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_findVisibleObjects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderQueue * >(argp3);
  (arg1)->_findVisibleObjects(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_findElementAt(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::OverlayElement *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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","findElementAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","findElementAt", 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","findElementAt", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::OverlayElement *)(arg1)->findElementAt(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_get2DElementsIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::list< Ogre::OverlayContainer *,Ogre::STLAllocator< Ogre::OverlayContainer *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","get2DElementsIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (arg1)->get2DElementsIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Overlay::Overlay2DElementsIterator(static_cast< const Ogre::Overlay::Overlay2DElementsIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(argp1);
  result = (Ogre::String *) &((Ogre::Overlay const *)arg1)->getOrigin();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Overlay__notifyOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Overlay *arg1 = (Ogre::Overlay *) 0 ;
  Ogre::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_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Overlay *","_notifyOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Overlay * >(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( "", "Ogre::String const &","_notifyOrigin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyOrigin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->_notifyOrigin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassTextAreaOverlayElement;

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

SWIGINTERN VALUE
_wrap_new_TextAreaOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::TextAreaOverlayElement";
  Ogre::TextAreaOverlayElement *result = 0 ;
  
  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 &","Ogre::TextAreaOverlayElement", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::TextAreaOverlayElement", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::TextAreaOverlayElement *)new Ogre::TextAreaOverlayElement((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextAreaOverlayElement(Ogre::TextAreaOverlayElement *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setCaption(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::DisplayString *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setCaption", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__UTFString,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DisplayString const &","setCaption", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DisplayString const &","setCaption", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DisplayString * >(argp2);
  (arg1)->setCaption((Ogre::DisplayString const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setCharHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setCharHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setCharHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setCharHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getCharHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getCharHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::TextAreaOverlayElement const *)arg1)->getCharHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setSpaceWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setSpaceWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpaceWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSpaceWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getSpaceWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getSpaceWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::Real)((Ogre::TextAreaOverlayElement const *)arg1)->getSpaceWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setFontName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setFontName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(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( "", "Ogre::String const &","setFontName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFontName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setFontName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getFontName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getFontName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::TextAreaOverlayElement const *)arg1)->getFontName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::String *) &((Ogre::TextAreaOverlayElement const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::TextAreaOverlayElement const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::RenderOperation *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setColour(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::ColourValue *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getColour(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::TextAreaOverlayElement const *)arg1)->getColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setColourBottom(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::ColourValue *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setColourBottom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourBottom", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourBottom", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColourBottom((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getColourBottom(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getColourBottom", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::TextAreaOverlayElement const *)arg1)->getColourBottom();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setColourTop(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::ColourValue *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setColourTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourTop", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourTop", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColourTop((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getColourTop(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getColourTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::TextAreaOverlayElement const *)arg1)->getColourTop();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::TextAreaOverlayElement::Alignment arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement::Alignment","setAlignment", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextAreaOverlayElement::Alignment >(val2);
  (arg1)->setAlignment(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_getAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextAreaOverlayElement::Alignment 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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement const *","getAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  result = (Ogre::TextAreaOverlayElement::Alignment)((Ogre::TextAreaOverlayElement const *)arg1)->getAlignment();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement_setMetricsMode(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 0 ;
  Ogre::GuiMetricsMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","setMetricsMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GuiMetricsMode","setMetricsMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GuiMetricsMode >(val2);
  (arg1)->setMetricsMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElement__update(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElement *arg1 = (Ogre::TextAreaOverlayElement *) 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_Ogre__TextAreaOverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElement *","_update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElement * >(argp1);
  (arg1)->_update();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassOverlayElementFactory;

SWIGINTERN void
free_Ogre_OverlayElementFactory(Ogre::OverlayElementFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_OverlayElementFactory_createOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementFactory *arg1 = (Ogre::OverlayElementFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementFactory *","createOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementFactory * >(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( "", "Ogre::String const &","createOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElementFactory_destroyOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementFactory *arg1 = (Ogre::OverlayElementFactory *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementFactory *","destroyOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","destroyOverlayElement", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->destroyOverlayElement(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayElementFactory_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayElementFactory *arg1 = (Ogre::OverlayElementFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__OverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayElementFactory const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayElementFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::OverlayElementFactory const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPanelOverlayElementFactory;

SWIGINTERN VALUE
_wrap_PanelOverlayElementFactory_createOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElementFactory *arg1 = (Ogre::PanelOverlayElementFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__PanelOverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElementFactory *","createOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElementFactory * >(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( "", "Ogre::String const &","createOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PanelOverlayElementFactory_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::PanelOverlayElementFactory *arg1 = (Ogre::PanelOverlayElementFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PanelOverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PanelOverlayElementFactory const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PanelOverlayElementFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::PanelOverlayElementFactory const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PanelOverlayElementFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PanelOverlayElementFactory";
  Ogre::PanelOverlayElementFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PanelOverlayElementFactory *)new Ogre::PanelOverlayElementFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PanelOverlayElementFactory(Ogre::PanelOverlayElementFactory *arg1) {
    delete arg1;
}

swig_class SwigClassBorderPanelOverlayElementFactory;

SWIGINTERN VALUE
_wrap_BorderPanelOverlayElementFactory_createOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElementFactory *arg1 = (Ogre::BorderPanelOverlayElementFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__BorderPanelOverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElementFactory *","createOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElementFactory * >(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( "", "Ogre::String const &","createOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BorderPanelOverlayElementFactory_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::BorderPanelOverlayElementFactory *arg1 = (Ogre::BorderPanelOverlayElementFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BorderPanelOverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BorderPanelOverlayElementFactory const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BorderPanelOverlayElementFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::BorderPanelOverlayElementFactory const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_BorderPanelOverlayElementFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::BorderPanelOverlayElementFactory";
  Ogre::BorderPanelOverlayElementFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::BorderPanelOverlayElementFactory *)new Ogre::BorderPanelOverlayElementFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BorderPanelOverlayElementFactory(Ogre::BorderPanelOverlayElementFactory *arg1) {
    delete arg1;
}

swig_class SwigClassTextAreaOverlayElementFactory;

SWIGINTERN VALUE
_wrap_TextAreaOverlayElementFactory_createOverlayElement(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElementFactory *arg1 = (Ogre::TextAreaOverlayElementFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__TextAreaOverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElementFactory *","createOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElementFactory * >(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( "", "Ogre::String const &","createOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextAreaOverlayElementFactory_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::TextAreaOverlayElementFactory *arg1 = (Ogre::TextAreaOverlayElementFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TextAreaOverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextAreaOverlayElementFactory const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextAreaOverlayElementFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::TextAreaOverlayElementFactory const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TextAreaOverlayElementFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TextAreaOverlayElementFactory";
  Ogre::TextAreaOverlayElementFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TextAreaOverlayElementFactory *)new Ogre::TextAreaOverlayElementFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextAreaOverlayElementFactory(Ogre::TextAreaOverlayElementFactory *arg1) {
    delete arg1;
}

swig_class SwigClassOverlayManager;

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

SWIGINTERN VALUE
_wrap_new_OverlayManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::OverlayManager";
  Ogre::OverlayManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayManager *)new Ogre::OverlayManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getScriptPatterns(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","getScriptPatterns", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (Ogre::StringVector *) &((Ogre::OverlayManager const *)arg1)->getScriptPatterns();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getLoadingOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","getLoadingOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayManager const *)arg1)->getLoadingOrder();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_create(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Overlay *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Overlay *)(arg1)->create((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Overlay, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getByName(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Overlay *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","getByName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","getByName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getByName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Overlay *)(arg1)->getByName((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Overlay, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","destroy", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroy", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroy((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::Overlay *arg2 = (Ogre::Overlay *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Overlay, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Overlay *","destroy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Overlay * >(argp2);
  (arg1)->destroy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_destroy(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_Ogre__OverlayManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Overlay, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_OverlayManager_destroy__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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_OverlayManager_destroy__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "OverlayManager.destroy", 
    "    void OverlayManager.destroy(Ogre::String const &name)\n"
    "    void OverlayManager.destroy(Ogre::Overlay *overlay)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroyAll(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroyAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  (arg1)->destroyAll();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getOverlayIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::Overlay *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::Overlay * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","getOverlayIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (arg1)->getOverlayIterator();
  vresult = SWIG_NewPointerObj((new Ogre::OverlayManager::OverlayMapIterator(static_cast< const Ogre::OverlayManager::OverlayMapIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager__queueOverlaysForRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::RenderQueue *arg3 = (Ogre::RenderQueue *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","_queueOverlaysForRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_queueOverlaysForRendering", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_queueOverlaysForRendering", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderQueue * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","_queueOverlaysForRendering", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  (arg1)->_queueOverlaysForRendering(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_hasViewportChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","hasViewportChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (bool)((Ogre::OverlayManager const *)arg1)->hasViewportChanged();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getViewportHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","getViewportHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (int)((Ogre::OverlayManager const *)arg1)->getViewportHeight();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getViewportWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","getViewportWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (int)((Ogre::OverlayManager const *)arg1)->getViewportWidth();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getViewportAspectRatio(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","getViewportAspectRatio", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (Ogre::Real)((Ogre::OverlayManager const *)arg1)->getViewportAspectRatio();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getViewportOrientationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::OrientationMode 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","getViewportOrientationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (Ogre::OrientationMode)((Ogre::OverlayManager const *)arg1)->getViewportOrientationMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_createOverlayElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","createOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","createOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 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 &","createOverlayElement", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createOverlayElement", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  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_OverlayManager_createOverlayElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","createOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","createOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 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 &","createOverlayElement", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElement", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElement((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  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_OverlayManager_createOverlayElement(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_Ogre__OverlayManager, 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_OverlayManager_createOverlayElement__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_OverlayManager_createOverlayElement__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "OverlayManager.createOverlayElement", 
    "    Ogre::OverlayElement * OverlayManager.createOverlayElement(Ogre::String const &typeName, Ogre::String const &instanceName, bool isTemplate)\n"
    "    Ogre::OverlayElement * OverlayManager.createOverlayElement(Ogre::String const &typeName, Ogre::String const &instanceName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getOverlayElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","getOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","getOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","getOverlayElement", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::OverlayElement *)(arg1)->getOverlayElement((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getOverlayElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","getOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","getOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->getOverlayElement((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_getOverlayElement(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_Ogre__OverlayManager, 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_OverlayManager_getOverlayElement__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OverlayManager_getOverlayElement__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayManager.getOverlayElement", 
    "    Ogre::OverlayElement * OverlayManager.getOverlayElement(Ogre::String const &name, bool isTemplate)\n"
    "    Ogre::OverlayElement * OverlayManager.getOverlayElement(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_hasOverlayElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","hasOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","hasOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","hasOverlayElement", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)(arg1)->hasOverlayElement((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_hasOverlayElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","hasOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","hasOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->hasOverlayElement((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_hasOverlayElement(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_Ogre__OverlayManager, 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_OverlayManager_hasOverlayElement__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OverlayManager_hasOverlayElement__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayManager.hasOverlayElement", 
    "    bool OverlayManager.hasOverlayElement(Ogre::String const &name, bool isTemplate)\n"
    "    bool OverlayManager.hasOverlayElement(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroyOverlayElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroyOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","destroyOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","destroyOverlayElement", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->destroyOverlayElement((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroyOverlayElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroyOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","destroyOverlayElement", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyOverlayElement", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyOverlayElement((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroyOverlayElement__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroyOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","destroyOverlayElement", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","destroyOverlayElement", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->destroyOverlayElement(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroyOverlayElement__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::OverlayElement *arg2 = (Ogre::OverlayElement *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroyOverlayElement", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElement *","destroyOverlayElement", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElement * >(argp2);
  (arg1)->destroyOverlayElement(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_destroyOverlayElement(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_Ogre__OverlayManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__OverlayElement, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_OverlayManager_destroyOverlayElement__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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_OverlayManager_destroyOverlayElement__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__OverlayElement, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OverlayManager_destroyOverlayElement__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_OverlayManager_destroyOverlayElement__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "OverlayManager.destroyOverlayElement", 
    "    void OverlayManager.destroyOverlayElement(Ogre::String const &instanceName, bool isTemplate)\n"
    "    void OverlayManager.destroyOverlayElement(Ogre::String const &instanceName)\n"
    "    void OverlayManager.destroyOverlayElement(Ogre::OverlayElement *pInstance, bool isTemplate)\n"
    "    void OverlayManager.destroyOverlayElement(Ogre::OverlayElement *pInstance)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroyAllOverlayElements__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroyAllOverlayElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","destroyAllOverlayElements", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->destroyAllOverlayElements(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_destroyAllOverlayElements__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","destroyAllOverlayElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  (arg1)->destroyAllOverlayElements();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_destroyAllOverlayElements(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_Ogre__OverlayManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_OverlayManager_destroyAllOverlayElements__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_OverlayManager_destroyAllOverlayElements__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "OverlayManager.destroyAllOverlayElements", 
    "    void OverlayManager.destroyAllOverlayElements(bool isTemplate)\n"
    "    void OverlayManager.destroyAllOverlayElements()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_addOverlayElementFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::OverlayElementFactory *arg2 = (Ogre::OverlayElementFactory *) 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","addOverlayElementFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__OverlayElementFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::OverlayElementFactory *","addOverlayElementFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::OverlayElementFactory * >(argp2);
  (arg1)->addOverlayElementFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getOverlayElementFactoryMap(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::OverlayManager::FactoryMap *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","getOverlayElementFactoryMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (Ogre::OverlayManager::FactoryMap *) &((Ogre::OverlayManager const *)arg1)->getOverlayElementFactoryMap();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_createOverlayElementFromTemplate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","createOverlayElementFromTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","createOverlayElementFromTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromTemplate", 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 &","createOverlayElementFromTemplate", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromTemplate", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createOverlayElementFromTemplate", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromTemplate", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createOverlayElementFromTemplate", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElementFromTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_createOverlayElementFromTemplate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","createOverlayElementFromTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","createOverlayElementFromTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromTemplate", 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 &","createOverlayElementFromTemplate", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromTemplate", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createOverlayElementFromTemplate", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromTemplate", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElementFromTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_OverlayManager_createOverlayElementFromTemplate(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_OverlayManager_createOverlayElementFromTemplate__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__OverlayManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_OverlayManager_createOverlayElementFromTemplate__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "OverlayManager.createOverlayElementFromTemplate", 
    "    Ogre::OverlayElement * OverlayManager.createOverlayElementFromTemplate(Ogre::String const &templateName, Ogre::String const &typeName, Ogre::String const &instanceName, bool isTemplate)\n"
    "    Ogre::OverlayElement * OverlayManager.createOverlayElementFromTemplate(Ogre::String const &templateName, Ogre::String const &typeName, Ogre::String const &instanceName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_cloneOverlayElementFromTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","cloneOverlayElementFromTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","cloneOverlayElementFromTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","cloneOverlayElementFromTemplate", 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 &","cloneOverlayElementFromTemplate", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","cloneOverlayElementFromTemplate", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->cloneOverlayElementFromTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  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_OverlayManager_createOverlayElementFromFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::OverlayElement *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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","createOverlayElementFromFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(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( "", "Ogre::String const &","createOverlayElementFromFactory", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromFactory", 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 &","createOverlayElementFromFactory", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createOverlayElementFromFactory", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::OverlayElement *)(arg1)->createOverlayElementFromFactory((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayElement, 0 |  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_OverlayManager_getTemplateIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::OverlayElement *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::OverlayElement * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager *","getTemplateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  result = (arg1)->getTemplateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::OverlayManager::TemplateIterator(static_cast< const Ogre::OverlayManager::TemplateIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_isTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *arg1 = (Ogre::OverlayManager *) 0 ;
  Ogre::String arg2 ;
  void *argp1 = 0 ;
  int res1 = 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_Ogre__OverlayManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::OverlayManager const *","isTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::OverlayManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[0], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "Ogre::String","isTemplate", 2, argv[0] )); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (bool)((Ogre::OverlayManager const *)arg1)->isTemplate(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayManager *) &Ogre::OverlayManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_OverlayManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::OverlayManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::OverlayManager *)Ogre::OverlayManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__OverlayManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassParticleVisualData;

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

SWIGINTERN VALUE
_wrap_new_ParticleVisualData(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ParticleVisualData";
  Ogre::ParticleVisualData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleVisualData *)new Ogre::ParticleVisualData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleVisualData(Ogre::ParticleVisualData *arg1) {
    delete arg1;
}

swig_class SwigClassParticle;

SWIGINTERN VALUE
_wrap_Particle_mOwnDimensions_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","mOwnDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","mOwnDimensions", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->mOwnDimensions = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_mOwnDimensions_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","mOwnDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (bool) ((arg1)->mOwnDimensions);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_mWidth_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","mWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","mWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->mWidth = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_mWidth_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","mWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Real) ((arg1)->mWidth);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_mHeight_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","mHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","mHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->mHeight = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_mHeight_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","mHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Real) ((arg1)->mHeight);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_rotation_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Radian *arg2 = (Ogre::Radian *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","rotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian *","rotation", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  if (arg1) (arg1)->rotation = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_rotation_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","rotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Radian *)& ((arg1)->rotation);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_position_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","position", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  if (arg1) (arg1)->position = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_position_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Vector3 *)& ((arg1)->position);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_direction_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","direction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","direction", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  if (arg1) (arg1)->direction = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_direction_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","direction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Vector3 *)& ((arg1)->direction);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_colour_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::ColourValue *arg2 = (Ogre::ColourValue *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","colour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue *","colour", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  if (arg1) (arg1)->colour = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_colour_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","colour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::ColourValue *)& ((arg1)->colour);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_timeToLive_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","timeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","timeToLive", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->timeToLive = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_timeToLive_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","timeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Real) ((arg1)->timeToLive);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_totalTimeToLive_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","totalTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","totalTimeToLive", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->totalTimeToLive = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_totalTimeToLive_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","totalTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Real) ((arg1)->totalTimeToLive);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_rotationSpeed_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Radian *arg2 = (Ogre::Radian *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","rotationSpeed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian *","rotationSpeed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  if (arg1) (arg1)->rotationSpeed = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_rotationSpeed_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","rotationSpeed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Radian *)& ((arg1)->rotationSpeed);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_particleType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Particle::ParticleType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","particleType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Particle::ParticleType","particleType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Particle::ParticleType >(val2);
  if (arg1) (arg1)->particleType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_particleType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Particle::ParticleType 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","particleType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Particle::ParticleType) ((arg1)->particleType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Particle(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Particle";
  Ogre::Particle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Particle *)new Ogre::Particle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_setDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","setDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDimensions", 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","setDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_hasOwnDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle const *","hasOwnDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (bool)((Ogre::Particle const *)arg1)->hasOwnDimensions();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_getOwnWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle const *","getOwnWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Real)((Ogre::Particle const *)arg1)->getOwnWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_getOwnHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle const *","getOwnHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Real)((Ogre::Particle const *)arg1)->getOwnHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_setRotation(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::Radian *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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","setRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(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 const &","setRotation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setRotation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setRotation((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_getRotation(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle const *","getRotation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::Radian *) &((Ogre::Particle const *)arg1)->getRotation();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle__notifyOwner(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::ParticleSystem *arg2 = (Ogre::ParticleSystem *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","_notifyOwner", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_notifyOwner", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystem * >(argp2);
  (arg1)->_notifyOwner(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle__notifyVisualData(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  Ogre::ParticleVisualData *arg2 = (Ogre::ParticleVisualData *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","_notifyVisualData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleVisualData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleVisualData *","_notifyVisualData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleVisualData * >(argp2);
  (arg1)->_notifyVisualData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_getVisualData(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParticleVisualData *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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle const *","getVisualData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  result = (Ogre::ParticleVisualData *)((Ogre::Particle const *)arg1)->getVisualData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleVisualData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Particle_resetDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Particle *arg1 = (Ogre::Particle *) 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_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Particle *","resetDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Particle * >(argp1);
  (arg1)->resetDimensions();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Particle(Ogre::Particle *arg1) {
    delete arg1;
}

swig_class SwigClassParticleAffector;

SWIGINTERN void
free_Ogre_ParticleAffector(Ogre::ParticleAffector *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleAffector__initParticle(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleAffector *arg1 = (Ogre::ParticleAffector *) 0 ;
  Ogre::Particle *arg2 = (Ogre::Particle *) 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_Ogre__ParticleAffector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleAffector *","_initParticle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleAffector * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Particle *","_initParticle", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Particle * >(argp2);
  (arg1)->_initParticle(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleAffector__affectParticles(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleAffector *arg1 = (Ogre::ParticleAffector *) 0 ;
  Ogre::ParticleSystem *arg2 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleAffector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleAffector *","_affectParticles", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleAffector * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_affectParticles", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystem * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_affectParticles", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->_affectParticles(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleAffector_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleAffector *arg1 = (Ogre::ParticleAffector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleAffector, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleAffector const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleAffector * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleAffector const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassParticleAffectorFactory;

SWIGINTERN void
free_Ogre_ParticleAffectorFactory(Ogre::ParticleAffectorFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleAffectorFactory_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleAffectorFactory *arg1 = (Ogre::ParticleAffectorFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__ParticleAffectorFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleAffectorFactory const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleAffectorFactory * >(argp1);
  result = ((Ogre::ParticleAffectorFactory const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleAffectorFactory_createAffector(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleAffectorFactory *arg1 = (Ogre::ParticleAffectorFactory *) 0 ;
  Ogre::ParticleSystem *arg2 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::ParticleAffector *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_Ogre__ParticleAffectorFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleAffectorFactory *","createAffector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleAffectorFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","createAffector", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystem * >(argp2);
  result = (Ogre::ParticleAffector *)(arg1)->createAffector(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleAffectorFactory_destroyAffector(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleAffectorFactory *arg1 = (Ogre::ParticleAffectorFactory *) 0 ;
  Ogre::ParticleAffector *arg2 = (Ogre::ParticleAffector *) 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_Ogre__ParticleAffectorFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleAffectorFactory *","destroyAffector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleAffectorFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleAffector *","destroyAffector", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleAffector * >(argp2);
  (arg1)->destroyAffector(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassCmdAngle;

SWIGINTERN VALUE
_wrap_CmdAngle_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdAngle *arg1 = (Ogre::EmitterCommands::CmdAngle *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdAngle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdAngle const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdAngle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdAngle const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdAngle_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdAngle *arg1 = (Ogre::EmitterCommands::CmdAngle *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdAngle, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdAngle *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdAngle * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdAngle(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdAngle";
  Ogre::EmitterCommands::CmdAngle *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdAngle *)new Ogre::EmitterCommands::CmdAngle();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdAngle(Ogre::EmitterCommands::CmdAngle *arg1) {
    delete arg1;
}

swig_class SwigClassCmdColour;

SWIGINTERN VALUE
_wrap_CmdColour_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdColour *arg1 = (Ogre::EmitterCommands::CmdColour *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdColour, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdColour const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdColour * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdColour const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdColour_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdColour *arg1 = (Ogre::EmitterCommands::CmdColour *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdColour, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdColour *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdColour * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdColour(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdColour";
  Ogre::EmitterCommands::CmdColour *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdColour *)new Ogre::EmitterCommands::CmdColour();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdColour(Ogre::EmitterCommands::CmdColour *arg1) {
    delete arg1;
}

swig_class SwigClassCmdColourRangeStart;

SWIGINTERN VALUE
_wrap_CmdColourRangeStart_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdColourRangeStart *arg1 = (Ogre::EmitterCommands::CmdColourRangeStart *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdColourRangeStart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdColourRangeStart const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdColourRangeStart * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdColourRangeStart const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdColourRangeStart_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdColourRangeStart *arg1 = (Ogre::EmitterCommands::CmdColourRangeStart *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdColourRangeStart, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdColourRangeStart *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdColourRangeStart * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdColourRangeStart(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdColourRangeStart";
  Ogre::EmitterCommands::CmdColourRangeStart *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdColourRangeStart *)new Ogre::EmitterCommands::CmdColourRangeStart();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdColourRangeStart(Ogre::EmitterCommands::CmdColourRangeStart *arg1) {
    delete arg1;
}

swig_class SwigClassCmdColourRangeEnd;

SWIGINTERN VALUE
_wrap_CmdColourRangeEnd_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdColourRangeEnd *arg1 = (Ogre::EmitterCommands::CmdColourRangeEnd *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdColourRangeEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdColourRangeEnd const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdColourRangeEnd * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdColourRangeEnd const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdColourRangeEnd_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdColourRangeEnd *arg1 = (Ogre::EmitterCommands::CmdColourRangeEnd *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdColourRangeEnd, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdColourRangeEnd *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdColourRangeEnd * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdColourRangeEnd(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdColourRangeEnd";
  Ogre::EmitterCommands::CmdColourRangeEnd *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdColourRangeEnd *)new Ogre::EmitterCommands::CmdColourRangeEnd();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdColourRangeEnd(Ogre::EmitterCommands::CmdColourRangeEnd *arg1) {
    delete arg1;
}

swig_class SwigClassCmdDirection;

SWIGINTERN VALUE
_wrap_CmdDirection_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdDirection *arg1 = (Ogre::EmitterCommands::CmdDirection *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdDirection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdDirection const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdDirection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdDirection const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdDirection_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdDirection *arg1 = (Ogre::EmitterCommands::CmdDirection *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdDirection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdDirection *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdDirection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdDirection(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdDirection";
  Ogre::EmitterCommands::CmdDirection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdDirection *)new Ogre::EmitterCommands::CmdDirection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdDirection(Ogre::EmitterCommands::CmdDirection *arg1) {
    delete arg1;
}

swig_class SwigClassCmdUp;

SWIGINTERN VALUE
_wrap_CmdUp_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdUp *arg1 = (Ogre::EmitterCommands::CmdUp *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdUp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdUp const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdUp * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdUp const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdUp_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdUp *arg1 = (Ogre::EmitterCommands::CmdUp *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdUp, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdUp *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdUp * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdUp(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdUp";
  Ogre::EmitterCommands::CmdUp *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdUp *)new Ogre::EmitterCommands::CmdUp();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdUp(Ogre::EmitterCommands::CmdUp *arg1) {
    delete arg1;
}

swig_class SwigClassCmdEmissionRate;

SWIGINTERN VALUE
_wrap_CmdEmissionRate_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdEmissionRate *arg1 = (Ogre::EmitterCommands::CmdEmissionRate *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdEmissionRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdEmissionRate const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdEmissionRate * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdEmissionRate const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdEmissionRate_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdEmissionRate *arg1 = (Ogre::EmitterCommands::CmdEmissionRate *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdEmissionRate, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdEmissionRate *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdEmissionRate * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdEmissionRate(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdEmissionRate";
  Ogre::EmitterCommands::CmdEmissionRate *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdEmissionRate *)new Ogre::EmitterCommands::CmdEmissionRate();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdEmissionRate(Ogre::EmitterCommands::CmdEmissionRate *arg1) {
    delete arg1;
}

swig_class SwigClassCmdVelocity;

SWIGINTERN VALUE
_wrap_CmdVelocity_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdVelocity *arg1 = (Ogre::EmitterCommands::CmdVelocity *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdVelocity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdVelocity const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdVelocity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdVelocity const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdVelocity_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdVelocity *arg1 = (Ogre::EmitterCommands::CmdVelocity *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdVelocity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdVelocity *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdVelocity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdVelocity(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdVelocity";
  Ogre::EmitterCommands::CmdVelocity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdVelocity *)new Ogre::EmitterCommands::CmdVelocity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdVelocity(Ogre::EmitterCommands::CmdVelocity *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMinVelocity;

SWIGINTERN VALUE
_wrap_CmdMinVelocity_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinVelocity *arg1 = (Ogre::EmitterCommands::CmdMinVelocity *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMinVelocity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinVelocity const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinVelocity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMinVelocity const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMinVelocity_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinVelocity *arg1 = (Ogre::EmitterCommands::CmdMinVelocity *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMinVelocity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinVelocity *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinVelocity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMinVelocity(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMinVelocity";
  Ogre::EmitterCommands::CmdMinVelocity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMinVelocity *)new Ogre::EmitterCommands::CmdMinVelocity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinVelocity(Ogre::EmitterCommands::CmdMinVelocity *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMaxVelocity;

SWIGINTERN VALUE
_wrap_CmdMaxVelocity_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxVelocity *arg1 = (Ogre::EmitterCommands::CmdMaxVelocity *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMaxVelocity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxVelocity const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxVelocity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMaxVelocity const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMaxVelocity_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxVelocity *arg1 = (Ogre::EmitterCommands::CmdMaxVelocity *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMaxVelocity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxVelocity *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxVelocity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMaxVelocity(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMaxVelocity";
  Ogre::EmitterCommands::CmdMaxVelocity *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMaxVelocity *)new Ogre::EmitterCommands::CmdMaxVelocity();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxVelocity(Ogre::EmitterCommands::CmdMaxVelocity *arg1) {
    delete arg1;
}

swig_class SwigClassCmdTTL;

SWIGINTERN VALUE
_wrap_CmdTTL_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdTTL *arg1 = (Ogre::EmitterCommands::CmdTTL *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdTTL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdTTL const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdTTL * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdTTL const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdTTL_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdTTL *arg1 = (Ogre::EmitterCommands::CmdTTL *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdTTL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdTTL *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdTTL * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdTTL(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdTTL";
  Ogre::EmitterCommands::CmdTTL *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdTTL *)new Ogre::EmitterCommands::CmdTTL();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdTTL(Ogre::EmitterCommands::CmdTTL *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMinTTL;

SWIGINTERN VALUE
_wrap_CmdMinTTL_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinTTL *arg1 = (Ogre::EmitterCommands::CmdMinTTL *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMinTTL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinTTL const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinTTL * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMinTTL const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMinTTL_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinTTL *arg1 = (Ogre::EmitterCommands::CmdMinTTL *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMinTTL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinTTL *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinTTL * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMinTTL(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMinTTL";
  Ogre::EmitterCommands::CmdMinTTL *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMinTTL *)new Ogre::EmitterCommands::CmdMinTTL();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinTTL(Ogre::EmitterCommands::CmdMinTTL *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMaxTTL;

SWIGINTERN VALUE
_wrap_CmdMaxTTL_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxTTL *arg1 = (Ogre::EmitterCommands::CmdMaxTTL *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMaxTTL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxTTL const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxTTL * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMaxTTL const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMaxTTL_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxTTL *arg1 = (Ogre::EmitterCommands::CmdMaxTTL *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMaxTTL, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxTTL *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxTTL * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMaxTTL(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMaxTTL";
  Ogre::EmitterCommands::CmdMaxTTL *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMaxTTL *)new Ogre::EmitterCommands::CmdMaxTTL();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxTTL(Ogre::EmitterCommands::CmdMaxTTL *arg1) {
    delete arg1;
}

swig_class SwigClassCmdPosition;

SWIGINTERN VALUE
_wrap_CmdPosition_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdPosition *arg1 = (Ogre::EmitterCommands::CmdPosition *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdPosition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdPosition const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdPosition * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdPosition const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdPosition_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdPosition *arg1 = (Ogre::EmitterCommands::CmdPosition *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdPosition, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdPosition *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdPosition * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdPosition(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdPosition";
  Ogre::EmitterCommands::CmdPosition *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdPosition *)new Ogre::EmitterCommands::CmdPosition();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdPosition(Ogre::EmitterCommands::CmdPosition *arg1) {
    delete arg1;
}

swig_class SwigClassCmdDuration;

SWIGINTERN VALUE
_wrap_CmdDuration_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdDuration *arg1 = (Ogre::EmitterCommands::CmdDuration *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdDuration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdDuration const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdDuration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdDuration const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdDuration_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdDuration *arg1 = (Ogre::EmitterCommands::CmdDuration *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdDuration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdDuration *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdDuration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdDuration(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdDuration";
  Ogre::EmitterCommands::CmdDuration *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdDuration *)new Ogre::EmitterCommands::CmdDuration();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdDuration(Ogre::EmitterCommands::CmdDuration *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMinDuration;

SWIGINTERN VALUE
_wrap_CmdMinDuration_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinDuration *arg1 = (Ogre::EmitterCommands::CmdMinDuration *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMinDuration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinDuration const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinDuration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMinDuration const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMinDuration_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinDuration *arg1 = (Ogre::EmitterCommands::CmdMinDuration *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMinDuration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinDuration *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinDuration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMinDuration(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMinDuration";
  Ogre::EmitterCommands::CmdMinDuration *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMinDuration *)new Ogre::EmitterCommands::CmdMinDuration();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinDuration(Ogre::EmitterCommands::CmdMinDuration *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMaxDuration;

SWIGINTERN VALUE
_wrap_CmdMaxDuration_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxDuration *arg1 = (Ogre::EmitterCommands::CmdMaxDuration *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMaxDuration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxDuration const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxDuration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMaxDuration const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMaxDuration_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxDuration *arg1 = (Ogre::EmitterCommands::CmdMaxDuration *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMaxDuration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxDuration *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxDuration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMaxDuration(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMaxDuration";
  Ogre::EmitterCommands::CmdMaxDuration *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMaxDuration *)new Ogre::EmitterCommands::CmdMaxDuration();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxDuration(Ogre::EmitterCommands::CmdMaxDuration *arg1) {
    delete arg1;
}

swig_class SwigClassCmdRepeatDelay;

SWIGINTERN VALUE
_wrap_CmdRepeatDelay_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdRepeatDelay *arg1 = (Ogre::EmitterCommands::CmdRepeatDelay *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdRepeatDelay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdRepeatDelay const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdRepeatDelay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdRepeatDelay const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdRepeatDelay_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdRepeatDelay *arg1 = (Ogre::EmitterCommands::CmdRepeatDelay *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdRepeatDelay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdRepeatDelay *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdRepeatDelay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdRepeatDelay(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdRepeatDelay";
  Ogre::EmitterCommands::CmdRepeatDelay *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdRepeatDelay *)new Ogre::EmitterCommands::CmdRepeatDelay();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdRepeatDelay(Ogre::EmitterCommands::CmdRepeatDelay *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMinRepeatDelay;

SWIGINTERN VALUE
_wrap_CmdMinRepeatDelay_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinRepeatDelay *arg1 = (Ogre::EmitterCommands::CmdMinRepeatDelay *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMinRepeatDelay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinRepeatDelay const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinRepeatDelay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMinRepeatDelay const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMinRepeatDelay_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMinRepeatDelay *arg1 = (Ogre::EmitterCommands::CmdMinRepeatDelay *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMinRepeatDelay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMinRepeatDelay *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMinRepeatDelay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMinRepeatDelay(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMinRepeatDelay";
  Ogre::EmitterCommands::CmdMinRepeatDelay *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMinRepeatDelay *)new Ogre::EmitterCommands::CmdMinRepeatDelay();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMinRepeatDelay(Ogre::EmitterCommands::CmdMinRepeatDelay *arg1) {
    delete arg1;
}

swig_class SwigClassCmdMaxRepeatDelay;

SWIGINTERN VALUE
_wrap_CmdMaxRepeatDelay_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxRepeatDelay *arg1 = (Ogre::EmitterCommands::CmdMaxRepeatDelay *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdMaxRepeatDelay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxRepeatDelay const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxRepeatDelay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdMaxRepeatDelay const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdMaxRepeatDelay_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdMaxRepeatDelay *arg1 = (Ogre::EmitterCommands::CmdMaxRepeatDelay *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdMaxRepeatDelay, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdMaxRepeatDelay *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdMaxRepeatDelay * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdMaxRepeatDelay(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdMaxRepeatDelay";
  Ogre::EmitterCommands::CmdMaxRepeatDelay *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdMaxRepeatDelay *)new Ogre::EmitterCommands::CmdMaxRepeatDelay();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdMaxRepeatDelay(Ogre::EmitterCommands::CmdMaxRepeatDelay *arg1) {
    delete arg1;
}

swig_class SwigClassCmdName;

SWIGINTERN VALUE
_wrap_CmdName_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdName *arg1 = (Ogre::EmitterCommands::CmdName *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdName const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdName * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdName const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdName_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdName *arg1 = (Ogre::EmitterCommands::CmdName *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdName, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdName *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdName * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdName(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdName";
  Ogre::EmitterCommands::CmdName *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdName *)new Ogre::EmitterCommands::CmdName();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdName(Ogre::EmitterCommands::CmdName *arg1) {
    delete arg1;
}

swig_class SwigClassCmdEmittedEmitter;

SWIGINTERN VALUE
_wrap_CmdEmittedEmitter_doGet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdEmittedEmitter *arg1 = (Ogre::EmitterCommands::CmdEmittedEmitter *) 0 ;
  void *arg2 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  Ogre::String 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_Ogre__EmitterCommands__CmdEmittedEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdEmittedEmitter const *","doGet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdEmittedEmitter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","doGet", 2, argv[0] )); 
  }
  result = ((Ogre::EmitterCommands::CmdEmittedEmitter const *)arg1)->doGet((void const *)arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CmdEmittedEmitter_doSet(int argc, VALUE *argv, VALUE self) {
  Ogre::EmitterCommands::CmdEmittedEmitter *arg1 = (Ogre::EmitterCommands::CmdEmittedEmitter *) 0 ;
  void *arg2 = (void *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__EmitterCommands__CmdEmittedEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmitterCommands::CmdEmittedEmitter *","doSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmitterCommands::CmdEmittedEmitter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","doSet", 2, argv[0] )); 
  }
  {
    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 &","doSet", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","doSet", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->doSet(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CmdEmittedEmitter(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CmdEmittedEmitter";
  Ogre::EmitterCommands::CmdEmittedEmitter *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmitterCommands::CmdEmittedEmitter *)new Ogre::EmitterCommands::CmdEmittedEmitter();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmitterCommands_CmdEmittedEmitter(Ogre::EmitterCommands::CmdEmittedEmitter *arg1) {
    delete arg1;
}

swig_class SwigClassParticleEmitter;

SWIGINTERN void
free_Ogre_ParticleEmitter(Ogre::ParticleEmitter *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleEmitter_setPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Vector3 *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(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);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::ParticleEmitter const *)arg1)->getPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Vector3 *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(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 &","setDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::ParticleEmitter const *)arg1)->getDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setUp(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Vector3 *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setUp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(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 &","setUp", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setUp", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setUp((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getUp(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getUp", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::ParticleEmitter const *)arg1)->getUp();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setAngle(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Radian *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(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 const &","setAngle", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","setAngle", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->setAngle((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getAngle(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Radian *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getAngle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Radian *) &((Ogre::ParticleEmitter const *)arg1)->getAngle();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setParticleVelocity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setParticleVelocity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setParticleVelocity", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setParticleVelocity(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setParticleVelocity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setParticleVelocity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setParticleVelocity", 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","setParticleVelocity", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setParticleVelocity(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_setParticleVelocity(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_Ogre__ParticleEmitter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleEmitter_setParticleVelocity__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleEmitter, 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_ParticleEmitter_setParticleVelocity__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.setParticleVelocity", 
    "    void ParticleEmitter.setParticleVelocity(Ogre::Real speed)\n"
    "    void ParticleEmitter.setParticleVelocity(Ogre::Real min, Ogre::Real max)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMinParticleVelocity(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMinParticleVelocity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinParticleVelocity", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMinParticleVelocity(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMaxParticleVelocity(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMaxParticleVelocity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaxParticleVelocity", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaxParticleVelocity(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getParticleVelocity(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getParticleVelocity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getParticleVelocity();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMinParticleVelocity(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMinParticleVelocity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinParticleVelocity();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMaxParticleVelocity(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMaxParticleVelocity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxParticleVelocity();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setEmissionRate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setEmissionRate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setEmissionRate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setEmissionRate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getEmissionRate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getEmissionRate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getEmissionRate();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setTimeToLive__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTimeToLive", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTimeToLive(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setTimeToLive__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTimeToLive", 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","setTimeToLive", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setTimeToLive(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_setTimeToLive(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_Ogre__ParticleEmitter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleEmitter_setTimeToLive__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleEmitter, 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_ParticleEmitter_setTimeToLive__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.setTimeToLive", 
    "    void ParticleEmitter.setTimeToLive(Ogre::Real ttl)\n"
    "    void ParticleEmitter.setTimeToLive(Ogre::Real minTtl, Ogre::Real maxTtl)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMinTimeToLive(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMinTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinTimeToLive", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMinTimeToLive(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMaxTimeToLive(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMaxTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaxTimeToLive", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaxTimeToLive(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getTimeToLive(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getTimeToLive();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMinTimeToLive(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMinTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinTimeToLive();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMaxTimeToLive(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMaxTimeToLive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxTimeToLive();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setColour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::ColourValue *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setColour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  Ogre::ColourValue *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColour", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColour", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->setColour((Ogre::ColourValue const &)*arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_setColour(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_Ogre__ParticleEmitter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleEmitter_setColour__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleEmitter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ParticleEmitter_setColour__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.setColour", 
    "    void ParticleEmitter.setColour(Ogre::ColourValue const &colour)\n"
    "    void ParticleEmitter.setColour(Ogre::ColourValue const &colourStart, Ogre::ColourValue const &colourEnd)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setColourRangeStart(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::ColourValue *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setColourRangeStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourRangeStart", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourRangeStart", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColourRangeStart((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setColourRangeEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::ColourValue *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setColourRangeEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourRangeEnd", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourRangeEnd", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setColourRangeEnd((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getColour(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::ParticleEmitter const *)arg1)->getColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getColourRangeStart(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getColourRangeStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::ParticleEmitter const *)arg1)->getColourRangeStart();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getColourRangeEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getColourRangeEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::ParticleEmitter const *)arg1)->getColourRangeEnd();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter__getEmissionCount(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  unsigned short 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","_getEmissionCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_getEmissionCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (unsigned short)(arg1)->_getEmissionCount(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter__initParticle(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Particle *arg2 = (Ogre::Particle *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","_initParticle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Particle *","_initParticle", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Particle * >(argp2);
  (arg1)->_initParticle(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleEmitter const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (bool)((Ogre::ParticleEmitter const *)arg1)->getEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setStartTime(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setStartTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setStartTime", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setStartTime(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getStartTime(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getStartTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getStartTime();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setDuration__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDuration", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDuration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getDuration(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getDuration();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setDuration__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDuration", 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","setDuration", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setDuration(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_setDuration(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_Ogre__ParticleEmitter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleEmitter_setDuration__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleEmitter, 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_ParticleEmitter_setDuration__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.setDuration", 
    "    void ParticleEmitter.setDuration(Ogre::Real duration)\n"
    "    void ParticleEmitter.setDuration(Ogre::Real min, Ogre::Real max)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMinDuration(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMinDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinDuration", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMinDuration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMaxDuration(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMaxDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaxDuration", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaxDuration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMinDuration(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMinDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinDuration();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMaxDuration(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMaxDuration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxDuration();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setRepeatDelay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setRepeatDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRepeatDelay", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setRepeatDelay(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getRepeatDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getRepeatDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getRepeatDelay();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setRepeatDelay__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setRepeatDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRepeatDelay", 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","setRepeatDelay", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setRepeatDelay(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleEmitter_setRepeatDelay(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_Ogre__ParticleEmitter, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleEmitter_setRepeatDelay__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleEmitter, 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_ParticleEmitter_setRepeatDelay__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleEmitter.setRepeatDelay", 
    "    void ParticleEmitter.setRepeatDelay(Ogre::Real duration)\n"
    "    void ParticleEmitter.setRepeatDelay(Ogre::Real min, Ogre::Real max)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMinRepeatDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMinRepeatDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMinRepeatDelay", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMinRepeatDelay(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setMaxRepeatDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setMaxRepeatDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaxRepeatDelay", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaxRepeatDelay(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMinRepeatDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMinRepeatDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMinRepeatDelay();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getMaxRepeatDelay(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getMaxRepeatDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleEmitter const *)arg1)->getMaxRepeatDelay();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleEmitter const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setName(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(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( "", "Ogre::String const &","setName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_getEmittedEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","getEmittedEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleEmitter const *)arg1)->getEmittedEmitter();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setEmittedEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  Ogre::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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setEmittedEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(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( "", "Ogre::String const &","setEmittedEmitter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setEmittedEmitter", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setEmittedEmitter((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_isEmitted(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter const *","isEmitted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  result = (bool)((Ogre::ParticleEmitter const *)arg1)->isEmitted();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitter_setEmitted(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitter *arg1 = (Ogre::ParticleEmitter *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","setEmitted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitter * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEmitted", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEmitted(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassParticleEmitterFactory;

SWIGINTERN void
free_Ogre_ParticleEmitterFactory(Ogre::ParticleEmitterFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleEmitterFactory_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitterFactory *arg1 = (Ogre::ParticleEmitterFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__ParticleEmitterFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitterFactory const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitterFactory * >(argp1);
  result = ((Ogre::ParticleEmitterFactory const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitterFactory_createEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitterFactory *arg1 = (Ogre::ParticleEmitterFactory *) 0 ;
  Ogre::ParticleSystem *arg2 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::ParticleEmitter *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_Ogre__ParticleEmitterFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitterFactory *","createEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitterFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","createEmitter", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystem * >(argp2);
  result = (Ogre::ParticleEmitter *)(arg1)->createEmitter(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitterFactory_destroyEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitterFactory *arg1 = (Ogre::ParticleEmitterFactory *) 0 ;
  Ogre::ParticleEmitter *arg2 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleEmitterFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitterFactory *","destroyEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitterFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","destroyEmitter", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleEmitter * >(argp2);
  (arg1)->destroyEmitter(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassParticleIterator;


/*
  Document-method: Ogre::ParticleIterator.end

  call-seq:
    end -> bool

Return an iterator to past the end of the ParticleIterator.
*/
SWIGINTERN VALUE
_wrap_ParticleIterator_end(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleIterator *arg1 = (Ogre::ParticleIterator *) 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_Ogre__ParticleIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleIterator *","end", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleIterator * >(argp1);
  result = (bool)(arg1)->end();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleIterator_getNext(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleIterator *arg1 = (Ogre::ParticleIterator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Particle *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_Ogre__ParticleIterator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleIterator *","getNext", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleIterator * >(argp1);
  result = (Ogre::Particle *)(arg1)->getNext();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleIterator(Ogre::ParticleIterator *arg1) {
    delete arg1;
}

swig_class SwigClassConcreteNode;

SWIGINTERN VALUE
_wrap_ConcreteNode_token_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  Ogre::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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","token", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(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( "", "Ogre::String const &","token", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","token", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->token = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_token_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","token", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->token);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_file_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  Ogre::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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","file", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(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( "", "Ogre::String const &","file", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","file", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->file = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_file_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","file", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->file);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_line_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","line", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(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","line", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->line = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_line_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","line", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  result = (unsigned int) ((arg1)->line);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_type_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  Ogre::ConcreteNodeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ConcreteNodeType","type", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ConcreteNodeType >(val2);
  if (arg1) (arg1)->type = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_type_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ConcreteNodeType 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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  result = (Ogre::ConcreteNodeType) ((arg1)->type);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_children_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  Ogre::ConcreteNodeList *arg2 = (Ogre::ConcreteNodeList *) 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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","children", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ConcreteNodeList *","children", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ConcreteNodeList * >(argp2);
  if (arg1) (arg1)->children = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_children_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ConcreteNodeList *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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","children", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  result = (Ogre::ConcreteNodeList *)& ((arg1)->children);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_parent_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  Ogre::ConcreteNode *arg2 = (Ogre::ConcreteNode *) 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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ConcreteNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","parent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ConcreteNode * >(argp2);
  if (arg1) (arg1)->parent = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ConcreteNode_parent_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ConcreteNode *arg1 = (Ogre::ConcreteNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ConcreteNode *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_Ogre__ConcreteNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ConcreteNode *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ConcreteNode * >(argp1);
  result = (Ogre::ConcreteNode *) ((arg1)->parent);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ConcreteNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ConcreteNode(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ConcreteNode";
  Ogre::ConcreteNode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ConcreteNode *)new Ogre::ConcreteNode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ConcreteNode(Ogre::ConcreteNode *arg1) {
    delete arg1;
}

swig_class SwigClassAbstractNode;

SWIGINTERN VALUE
_wrap_AbstractNode_file_set(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  Ogre::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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","file", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(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( "", "Ogre::String const &","file", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","file", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->file = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_file_get(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","file", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->file);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_line_set(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","line", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(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","line", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->line = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_line_get(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","line", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (unsigned int) ((arg1)->line);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_type_set(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  Ogre::AbstractNodeType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeType","type", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::AbstractNodeType >(val2);
  if (arg1) (arg1)->type = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_type_get(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNodeType 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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::AbstractNodeType) ((arg1)->type);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_parent_set(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  Ogre::AbstractNode *arg2 = (Ogre::AbstractNode *) 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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AbstractNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","parent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNode * >(argp2);
  if (arg1) (arg1)->parent = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_parent_get(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::AbstractNode *) ((arg1)->parent);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_context_set(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  Ogre::Any *arg2 = (Ogre::Any *) 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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","context", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Any, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Any *","context", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Any * >(argp2);
  if (arg1) (arg1)->context = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_context_get(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Any *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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","context", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::Any *)& ((arg1)->context);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Any, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AbstractNode(Ogre::AbstractNode *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::AbstractNode.clone

  call-seq:
    clone -> AbstractNode

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_AbstractNode_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::AbstractNode *)((Ogre::AbstractNode const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AbstractNode_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = ((Ogre::AbstractNode const *)arg1)->getValue();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassAtomAbstractNode;

SWIGINTERN VALUE
_wrap_AtomAbstractNode_value_set(int argc, VALUE *argv, VALUE self) {
  Ogre::AtomAbstractNode *arg1 = (Ogre::AtomAbstractNode *) 0 ;
  Ogre::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_Ogre__AtomAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AtomAbstractNode *","value", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AtomAbstractNode * >(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( "", "Ogre::String const &","value", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","value", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->value = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AtomAbstractNode_value_get(int argc, VALUE *argv, VALUE self) {
  Ogre::AtomAbstractNode *arg1 = (Ogre::AtomAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__AtomAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AtomAbstractNode *","value", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AtomAbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->value);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AtomAbstractNode_id_set(int argc, VALUE *argv, VALUE self) {
  Ogre::AtomAbstractNode *arg1 = (Ogre::AtomAbstractNode *) 0 ;
  Ogre::uint32 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_Ogre__AtomAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AtomAbstractNode *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AtomAbstractNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","id", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  if (arg1) (arg1)->id = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AtomAbstractNode_id_get(int argc, VALUE *argv, VALUE self) {
  Ogre::AtomAbstractNode *arg1 = (Ogre::AtomAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__AtomAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AtomAbstractNode *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AtomAbstractNode * >(argp1);
  result = (Ogre::uint32) ((arg1)->id);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_AtomAbstractNode(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::AtomAbstractNode";
  Ogre::AtomAbstractNode *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__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","Ogre::AtomAbstractNode", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::AtomAbstractNode *)new Ogre::AtomAbstractNode(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::AtomAbstractNode.clone

  call-seq:
    clone -> AbstractNode

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_AtomAbstractNode_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::AtomAbstractNode *arg1 = (Ogre::AtomAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__AtomAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AtomAbstractNode const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AtomAbstractNode * >(argp1);
  result = (Ogre::AbstractNode *)((Ogre::AtomAbstractNode const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AtomAbstractNode_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::AtomAbstractNode *arg1 = (Ogre::AtomAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__AtomAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AtomAbstractNode const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AtomAbstractNode * >(argp1);
  result = ((Ogre::AtomAbstractNode const *)arg1)->getValue();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_AtomAbstractNode(Ogre::AtomAbstractNode *arg1) {
    delete arg1;
}

swig_class SwigClassObjectAbstractNode;

SWIGINTERN VALUE
_wrap_ObjectAbstractNode_name_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(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( "", "Ogre::String const &","name", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","name", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_name_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->name);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_cls_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","cls", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(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( "", "Ogre::String const &","cls", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","cls", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->cls = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_cls_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","cls", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->cls);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_bases_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  std::vector< Ogre::String,std::allocator< Ogre::String > > *arg2 = (std::vector< Ogre::String,std::allocator< Ogre::String > > *) 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","bases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "std::vector< Ogre::String,std::allocator< Ogre::String > > *","bases", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< std::vector< Ogre::String,std::allocator< Ogre::String > > * >(argp2);
  if (arg1) (arg1)->bases = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_bases_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  std::vector< Ogre::String,std::allocator< Ogre::String > > *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","bases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (std::vector< Ogre::String,std::allocator< Ogre::String > > *)& ((arg1)->bases);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_id_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::uint32 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","id", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  if (arg1) (arg1)->id = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_id_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::uint32) ((arg1)->id);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_abstract_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","abstract", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","abstract", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->abstract = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_abstract_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","abstract", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (bool) ((arg1)->abstract);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_children_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::AbstractNodeList *arg2 = (Ogre::AbstractNodeList *) 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","children", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeList *","children", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNodeList * >(argp2);
  if (arg1) (arg1)->children = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_children_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNodeList *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","children", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::AbstractNodeList *)& ((arg1)->children);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ObjectAbstractNode.values

  call-seq:
    values -> AbstractNodeList

Return an Array of value elements.
*/

/*
  Document-method: Ogre::ObjectAbstractNode.values=

  call-seq:
    values=(x) -> AbstractNodeList

Return an Array of value elements.
*/
SWIGINTERN VALUE
_wrap_ObjectAbstractNode_values_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::AbstractNodeList *arg2 = (Ogre::AbstractNodeList *) 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","values", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeList *","values", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNodeList * >(argp2);
  if (arg1) (arg1)->values = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_values_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNodeList *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","values", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::AbstractNodeList *)& ((arg1)->values);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_overrides_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::AbstractNodeList *arg2 = (Ogre::AbstractNodeList *) 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","overrides", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeList *","overrides", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNodeList * >(argp2);
  if (arg1) (arg1)->overrides = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_overrides_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNodeList *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","overrides", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::AbstractNodeList *)& ((arg1)->overrides);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ObjectAbstractNode(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ObjectAbstractNode";
  Ogre::ObjectAbstractNode *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__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","Ogre::ObjectAbstractNode", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::ObjectAbstractNode *)new Ogre::ObjectAbstractNode(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ObjectAbstractNode.clone

  call-seq:
    clone -> AbstractNode

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_ObjectAbstractNode_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::AbstractNode *)((Ogre::ObjectAbstractNode const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = ((Ogre::ObjectAbstractNode const *)arg1)->getValue();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_addVariable(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","addVariable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(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( "", "Ogre::String const &","addVariable", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addVariable", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addVariable((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_setVariable(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","setVariable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(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( "", "Ogre::String const &","setVariable", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setVariable", 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 &","setVariable", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setVariable", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setVariable((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_getVariable(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< std::pair< bool,std::string > > 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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode const *","getVariable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(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( "", "Ogre::String const &","getVariable", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getVariable", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::ObjectAbstractNode const *)arg1)->getVariable((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::String >(static_cast< const std::pair< bool,Ogre::String >& >(result))), SWIGTYPE_p_std__pairT_bool_std__string_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ObjectAbstractNode_getVariables(int argc, VALUE *argv, VALUE self) {
  Ogre::ObjectAbstractNode *arg1 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::map< Ogre::String,Ogre::String,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *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_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode const *","getVariables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp1);
  result = (Ogre::map< Ogre::String,Ogre::String,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *) &((Ogre::ObjectAbstractNode const *)arg1)->getVariables();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), 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, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ObjectAbstractNode(Ogre::ObjectAbstractNode *arg1) {
    delete arg1;
}

swig_class SwigClassPropertyAbstractNode;

SWIGINTERN VALUE
_wrap_PropertyAbstractNode_name_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  Ogre::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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(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( "", "Ogre::String const &","name", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","name", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PropertyAbstractNode_name_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->name);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PropertyAbstractNode_id_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  Ogre::uint32 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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","id", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  if (arg1) (arg1)->id = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PropertyAbstractNode_id_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode *","id", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(argp1);
  result = (Ogre::uint32) ((arg1)->id);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PropertyAbstractNode.values

  call-seq:
    values -> AbstractNodeList

Return an Array of value elements.
*/

/*
  Document-method: Ogre::PropertyAbstractNode.values=

  call-seq:
    values=(x) -> AbstractNodeList

Return an Array of value elements.
*/
SWIGINTERN VALUE
_wrap_PropertyAbstractNode_values_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  Ogre::AbstractNodeList *arg2 = (Ogre::AbstractNodeList *) 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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode *","values", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeList *","values", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNodeList * >(argp2);
  if (arg1) (arg1)->values = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PropertyAbstractNode_values_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNodeList *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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode *","values", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(argp1);
  result = (Ogre::AbstractNodeList *)& ((arg1)->values);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PropertyAbstractNode(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PropertyAbstractNode";
  Ogre::PropertyAbstractNode *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__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","Ogre::PropertyAbstractNode", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::PropertyAbstractNode *)new Ogre::PropertyAbstractNode(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::PropertyAbstractNode.clone

  call-seq:
    clone -> AbstractNode

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_PropertyAbstractNode_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(argp1);
  result = (Ogre::AbstractNode *)((Ogre::PropertyAbstractNode const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PropertyAbstractNode_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::PropertyAbstractNode *arg1 = (Ogre::PropertyAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__PropertyAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PropertyAbstractNode const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PropertyAbstractNode * >(argp1);
  result = ((Ogre::PropertyAbstractNode const *)arg1)->getValue();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PropertyAbstractNode(Ogre::PropertyAbstractNode *arg1) {
    delete arg1;
}

swig_class SwigClassImportAbstractNode;

SWIGINTERN VALUE
_wrap_ImportAbstractNode_target_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ImportAbstractNode *arg1 = (Ogre::ImportAbstractNode *) 0 ;
  Ogre::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_Ogre__ImportAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ImportAbstractNode *","target", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ImportAbstractNode * >(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( "", "Ogre::String const &","target", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","target", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->target = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ImportAbstractNode_target_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ImportAbstractNode *arg1 = (Ogre::ImportAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ImportAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ImportAbstractNode *","target", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ImportAbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->target);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ImportAbstractNode_source_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ImportAbstractNode *arg1 = (Ogre::ImportAbstractNode *) 0 ;
  Ogre::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_Ogre__ImportAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ImportAbstractNode *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ImportAbstractNode * >(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( "", "Ogre::String const &","source", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","source", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->source = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ImportAbstractNode_source_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ImportAbstractNode *arg1 = (Ogre::ImportAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ImportAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ImportAbstractNode *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ImportAbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->source);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ImportAbstractNode(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ImportAbstractNode";
  Ogre::ImportAbstractNode *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ImportAbstractNode *)new Ogre::ImportAbstractNode();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ImportAbstractNode.clone

  call-seq:
    clone -> AbstractNode

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_ImportAbstractNode_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::ImportAbstractNode *arg1 = (Ogre::ImportAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__ImportAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ImportAbstractNode const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ImportAbstractNode * >(argp1);
  result = (Ogre::AbstractNode *)((Ogre::ImportAbstractNode const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ImportAbstractNode_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::ImportAbstractNode *arg1 = (Ogre::ImportAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__ImportAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ImportAbstractNode const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ImportAbstractNode * >(argp1);
  result = ((Ogre::ImportAbstractNode const *)arg1)->getValue();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ImportAbstractNode(Ogre::ImportAbstractNode *arg1) {
    delete arg1;
}

swig_class SwigClassVariableAccessAbstractNode;

SWIGINTERN VALUE
_wrap_VariableAccessAbstractNode_name_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VariableAccessAbstractNode *arg1 = (Ogre::VariableAccessAbstractNode *) 0 ;
  Ogre::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_Ogre__VariableAccessAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VariableAccessAbstractNode *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VariableAccessAbstractNode * >(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( "", "Ogre::String const &","name", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","name", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->name = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VariableAccessAbstractNode_name_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VariableAccessAbstractNode *arg1 = (Ogre::VariableAccessAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__VariableAccessAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VariableAccessAbstractNode *","name", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VariableAccessAbstractNode * >(argp1);
  result = (Ogre::String *) & ((arg1)->name);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VariableAccessAbstractNode(int argc, VALUE *argv, VALUE self) {
  Ogre::AbstractNode *arg1 = (Ogre::AbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::VariableAccessAbstractNode";
  Ogre::VariableAccessAbstractNode *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__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","Ogre::VariableAccessAbstractNode", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::AbstractNode * >(argp1);
  result = (Ogre::VariableAccessAbstractNode *)new Ogre::VariableAccessAbstractNode(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::VariableAccessAbstractNode.clone

  call-seq:
    clone -> AbstractNode

Create a duplicate of the class.
*/
SWIGINTERN VALUE
_wrap_VariableAccessAbstractNode_clone(int argc, VALUE *argv, VALUE self) {
  Ogre::VariableAccessAbstractNode *arg1 = (Ogre::VariableAccessAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__VariableAccessAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VariableAccessAbstractNode const *","clone", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VariableAccessAbstractNode * >(argp1);
  result = (Ogre::AbstractNode *)((Ogre::VariableAccessAbstractNode const *)arg1)->clone();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VariableAccessAbstractNode_getValue(int argc, VALUE *argv, VALUE self) {
  Ogre::VariableAccessAbstractNode *arg1 = (Ogre::VariableAccessAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String 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_Ogre__VariableAccessAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VariableAccessAbstractNode const *","getValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VariableAccessAbstractNode * >(argp1);
  result = ((Ogre::VariableAccessAbstractNode const *)arg1)->getValue();
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VariableAccessAbstractNode(Ogre::VariableAccessAbstractNode *arg1) {
    delete arg1;
}

swig_class SwigClassScriptCompiler;

SWIGINTERN VALUE
_wrap_ScriptCompiler_formatErrorCode(int argc, VALUE *argv, VALUE self) {
  Ogre::uint32 arg1 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  Ogre::String result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::ScriptCompiler::formatErrorCode", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint32 >(val1);
  result = Ogre::ScriptCompiler::formatErrorCode(arg1);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ScriptCompiler(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ScriptCompiler";
  Ogre::ScriptCompiler *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptCompiler *)new Ogre::ScriptCompiler();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptCompiler(Ogre::ScriptCompiler *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ScriptCompiler_compile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(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( "", "Ogre::String const &","compile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","compile", 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 &","compile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","compile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","compile", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","compile", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (bool)(arg1)->compile((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler_compile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::ConcreteNodeListPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ConcreteNodeListPtr const &","compile", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ConcreteNodeListPtr const &","compile", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ConcreteNodeListPtr * >(argp2);
  {
    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 &","compile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","compile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->compile((Ogre::ConcreteNodeListPtr const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ScriptCompiler_compile(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_Ogre__ScriptCompiler, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ScriptCompiler_compile__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ScriptCompiler_compile__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ScriptCompiler.compile", 
    "    bool ScriptCompiler.compile(Ogre::String const &str, Ogre::String const &source, Ogre::String const &group)\n"
    "    bool ScriptCompiler.compile(Ogre::ConcreteNodeListPtr const &nodes, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler__generateAST__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_generateAST", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(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( "", "Ogre::String const &","_generateAST", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 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 &","_generateAST", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_generateAST", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_generateAST", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","_generateAST", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj((new Ogre::AbstractNodeListPtr(static_cast< const Ogre::AbstractNodeListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ScriptCompiler__generateAST__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > result;
  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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_generateAST", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(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( "", "Ogre::String const &","_generateAST", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 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 &","_generateAST", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_generateAST", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_generateAST", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj((new Ogre::AbstractNodeListPtr(static_cast< const Ogre::AbstractNodeListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ScriptCompiler__generateAST__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_generateAST", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(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( "", "Ogre::String const &","_generateAST", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 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 &","_generateAST", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_generateAST", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::AbstractNodeListPtr(static_cast< const Ogre::AbstractNodeListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ScriptCompiler__generateAST__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_generateAST", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(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( "", "Ogre::String const &","_generateAST", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 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 &","_generateAST", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_generateAST", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->_generateAST((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::AbstractNodeListPtr(static_cast< const Ogre::AbstractNodeListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ScriptCompiler__generateAST(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__ScriptCompiler, 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_ScriptCompiler__generateAST__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ScriptCompiler__generateAST__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 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) {
          {
            int res = SWIG_AsVal_bool(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_ScriptCompiler__generateAST__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ScriptCompiler__generateAST__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ScriptCompiler._generateAST", 
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generateAST(Ogre::String const &str, Ogre::String const &source, bool doImports, bool doObjects, bool doVariables)\n"
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generateAST(Ogre::String const &str, Ogre::String const &source, bool doImports, bool doObjects)\n"
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generateAST(Ogre::String const &str, Ogre::String const &source, bool doImports)\n"
    "    Ogre::AbstractNodeListPtr ScriptCompiler._generateAST(Ogre::String const &str, Ogre::String const &source)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler__compile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > arg2 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::AbstractNodeListPtr * >(argp2));
    }
  }
  {
    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 &","_compile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_compile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_compile", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_compile", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","_compile", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler__compile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > arg2 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool result;
  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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::AbstractNodeListPtr * >(argp2));
    }
  }
  {
    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 &","_compile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_compile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_compile", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_compile", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler__compile__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > arg2 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  bool 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::AbstractNodeListPtr * >(argp2));
    }
  }
  {
    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 &","_compile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_compile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_compile", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler__compile__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::AbstractNodePtr,Ogre::STLAllocator< Ogre::AbstractNodePtr,Ogre::GeneralAllocPolicy > >::type > > arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodeListPtr","_compile", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::AbstractNodeListPtr * >(argp2));
    }
  }
  {
    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 &","_compile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_compile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)(arg1)->_compile(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ScriptCompiler__compile(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__ScriptCompiler, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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_ScriptCompiler__compile__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ScriptCompiler__compile__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_ScriptCompiler__compile__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_ScriptCompiler__compile__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "ScriptCompiler._compile", 
    "    bool ScriptCompiler._compile(Ogre::AbstractNodeListPtr nodes, Ogre::String const &group, bool doImports, bool doObjects, bool doVariables)\n"
    "    bool ScriptCompiler._compile(Ogre::AbstractNodeListPtr nodes, Ogre::String const &group, bool doImports, bool doObjects)\n"
    "    bool ScriptCompiler._compile(Ogre::AbstractNodeListPtr nodes, Ogre::String const &group, bool doImports)\n"
    "    bool ScriptCompiler._compile(Ogre::AbstractNodeListPtr nodes, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler_addError__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::String *arg3 = 0 ;
  int arg4 ;
  Ogre::String *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  
  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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","addError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","addError", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  {
    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 &","addError", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addError", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","addError", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","addError", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addError", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  (arg1)->addError(arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler_addError__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::String *arg3 = 0 ;
  int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","addError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","addError", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  {
    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 &","addError", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addError", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","addError", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  (arg1)->addError(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ScriptCompiler_addError(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ScriptCompiler_addError__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ScriptCompiler, 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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_ScriptCompiler_addError__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "ScriptCompiler.addError", 
    "    void ScriptCompiler.addError(Ogre::uint32 code, Ogre::String const &file, int line, Ogre::String const &msg)\n"
    "    void ScriptCompiler.addError(Ogre::uint32 code, Ogre::String const &file, int line)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler_setListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::ScriptCompilerListener *arg2 = (Ogre::ScriptCompilerListener *) 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","setListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompilerListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerListener *","setListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompilerListener * >(argp2);
  (arg1)->setListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler_getListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ScriptCompilerListener *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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","getListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  result = (Ogre::ScriptCompilerListener *)(arg1)->getListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler_getResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler const *","getResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  result = (Ogre::String *) &((Ogre::ScriptCompiler const *)arg1)->getResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompiler__fireEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::ScriptCompilerEvent *arg2 = (Ogre::ScriptCompilerEvent *) 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 ;
  bool 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_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","_fireEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerEvent *","_fireEvent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompilerEvent * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","_fireEvent", 3, argv[1] )); 
  }
  result = (bool)(arg1)->_fireEvent(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_ScriptCompilerEvent_mType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerEvent *arg1 = (Ogre::ScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__ScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerEvent *","mType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerEvent * >(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( "", "Ogre::String const &","mType", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mType", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mType = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerEvent_mType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerEvent *arg1 = (Ogre::ScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerEvent *","mType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mType);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::ScriptCompilerEvent";
  Ogre::ScriptCompilerEvent *result = 0 ;
  
  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 &","Ogre::ScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::ScriptCompilerEvent *)new Ogre::ScriptCompilerEvent((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptCompilerEvent(Ogre::ScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassScriptCompilerListener;

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

SWIGINTERN VALUE
_wrap_new_ScriptCompilerListener(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ScriptCompilerListener";
  Ogre::ScriptCompilerListener *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptCompilerListener *)new Ogre::ScriptCompilerListener();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptCompilerListener(Ogre::ScriptCompilerListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ScriptCompilerListener_importFile(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerListener *arg1 = (Ogre::ScriptCompilerListener *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::ConcreteNodePtr,Ogre::STLAllocator< Ogre::ConcreteNodePtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ScriptCompilerListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerListener *","importFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","importFile", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  {
    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 &","importFile", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","importFile", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->importFile(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ConcreteNodeListPtr(static_cast< const Ogre::ConcreteNodeListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerListener_preConversion(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerListener *arg1 = (Ogre::ScriptCompilerListener *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::ConcreteNodePtr,Ogre::STLAllocator< Ogre::ConcreteNodePtr,Ogre::GeneralAllocPolicy > >::type > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__ScriptCompilerListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerListener *","preConversion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","preConversion", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ConcreteNodeListPtr","preConversion", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ConcreteNodeListPtr","preConversion", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::ConcreteNodeListPtr * >(argp3));
    }
  }
  (arg1)->preConversion(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerListener_postConversion(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerListener *arg1 = (Ogre::ScriptCompilerListener *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodeListPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  bool 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_Ogre__ScriptCompilerListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerListener *","postConversion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","postConversion", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__AbstractNodePtr_Ogre__STLAllocatorT_Ogre__AbstractNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodeListPtr const &","postConversion", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodeListPtr const &","postConversion", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodeListPtr * >(argp3);
  result = (bool)(arg1)->postConversion(arg2,(Ogre::AbstractNodeListPtr const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerListener_handleError(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerListener *arg1 = (Ogre::ScriptCompilerListener *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::uint32 arg3 ;
  Ogre::String *arg4 = 0 ;
  int arg5 ;
  Ogre::String *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  int res6 = SWIG_OLDOBJ ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ScriptCompilerListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerListener *","handleError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","handleError", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","handleError", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","handleError", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","handleError", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "int","handleError", 5, argv[3] ));
  } 
  arg5 = static_cast< int >(val5);
  {
    std::string *ptr = (std::string *)0;
    res6 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res6)) {
      SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::String const &","handleError", 6, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","handleError", 6, argv[4])); 
    }
    arg6 = ptr;
  }
  (arg1)->handleError(arg2,arg3,(Ogre::String const &)*arg4,arg5,(Ogre::String const &)*arg6);
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res6)) delete arg6;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerListener_handleEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerListener *arg1 = (Ogre::ScriptCompilerListener *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::ScriptCompilerEvent *arg3 = (Ogre::ScriptCompilerEvent *) 0 ;
  void *arg4 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 ;
  bool 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_Ogre__ScriptCompilerListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerListener *","handleEvent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","handleEvent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerEvent *","handleEvent", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ScriptCompilerEvent * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2],SWIG_as_voidptrptr(&arg4), 0, 0);
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "void *","handleEvent", 4, argv[2] )); 
  }
  result = (bool)(arg1)->handleEvent(arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassScriptCompilerManager;

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

SWIGINTERN VALUE
_wrap_new_ScriptCompilerManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ScriptCompilerManager";
  Ogre::ScriptCompilerManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptCompilerManager *)new Ogre::ScriptCompilerManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptCompilerManager(Ogre::ScriptCompilerManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ScriptCompilerManager_setListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  Ogre::ScriptCompilerListener *arg2 = (Ogre::ScriptCompilerListener *) 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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","setListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompilerListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerListener *","setListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompilerListener * >(argp2);
  (arg1)->setListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_getListener(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ScriptCompilerListener *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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","getListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  result = (Ogre::ScriptCompilerListener *)(arg1)->getListener();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerListener, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_addTranslatorManager(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  Ogre::ScriptTranslatorManager *arg2 = (Ogre::ScriptTranslatorManager *) 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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","addTranslatorManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptTranslatorManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptTranslatorManager *","addTranslatorManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptTranslatorManager * >(argp2);
  (arg1)->addTranslatorManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_removeTranslatorManager(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  Ogre::ScriptTranslatorManager *arg2 = (Ogre::ScriptTranslatorManager *) 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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","removeTranslatorManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptTranslatorManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptTranslatorManager *","removeTranslatorManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptTranslatorManager * >(argp2);
  (arg1)->removeTranslatorManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_clearTranslatorManagers(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","clearTranslatorManagers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  (arg1)->clearTranslatorManagers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_getTranslator(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  Ogre::AbstractNodePtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ScriptTranslator *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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","getTranslator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","getTranslator", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","getTranslator", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp2);
  result = (Ogre::ScriptTranslator *)(arg1)->getTranslator((Ogre::AbstractNodePtr const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptTranslator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_addScriptPattern(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  Ogre::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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","addScriptPattern", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(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( "", "Ogre::String const &","addScriptPattern", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addScriptPattern", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addScriptPattern((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_getScriptPatterns(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager const *","getScriptPatterns", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  result = (Ogre::StringVector *) &((Ogre::ScriptCompilerManager const *)arg1)->getScriptPatterns();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_getLoadingOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *arg1 = (Ogre::ScriptCompilerManager *) 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_Ogre__ScriptCompilerManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompilerManager const *","getLoadingOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompilerManager * >(argp1);
  result = (Ogre::Real)((Ogre::ScriptCompilerManager const *)arg1)->getLoadingOrder();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptCompilerManager *) &Ogre::ScriptCompilerManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptCompilerManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompilerManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptCompilerManager *)Ogre::ScriptCompilerManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptCompilerManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPreApplyTextureAliasesScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_PreApplyTextureAliasesScriptCompilerEvent_mMaterial_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PreApplyTextureAliasesScriptCompilerEvent *arg1 = (Ogre::PreApplyTextureAliasesScriptCompilerEvent *) 0 ;
  Ogre::Material *arg2 = (Ogre::Material *) 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_Ogre__PreApplyTextureAliasesScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PreApplyTextureAliasesScriptCompilerEvent *","mMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PreApplyTextureAliasesScriptCompilerEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Material, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Material *","mMaterial", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Material * >(argp2);
  if (arg1) (arg1)->mMaterial = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PreApplyTextureAliasesScriptCompilerEvent_mMaterial_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PreApplyTextureAliasesScriptCompilerEvent *arg1 = (Ogre::PreApplyTextureAliasesScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Material *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_Ogre__PreApplyTextureAliasesScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PreApplyTextureAliasesScriptCompilerEvent *","mMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PreApplyTextureAliasesScriptCompilerEvent * >(argp1);
  result = (Ogre::Material *) ((arg1)->mMaterial);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PreApplyTextureAliasesScriptCompilerEvent_mAliases_set(int argc, VALUE *argv, VALUE self) {
  Ogre::PreApplyTextureAliasesScriptCompilerEvent *arg1 = (Ogre::PreApplyTextureAliasesScriptCompilerEvent *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = (Ogre::AliasTextureNamePairList *) 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_Ogre__PreApplyTextureAliasesScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PreApplyTextureAliasesScriptCompilerEvent *","mAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PreApplyTextureAliasesScriptCompilerEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,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_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList *","mAliases", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  if (arg1) (arg1)->mAliases = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PreApplyTextureAliasesScriptCompilerEvent_mAliases_get(int argc, VALUE *argv, VALUE self) {
  Ogre::PreApplyTextureAliasesScriptCompilerEvent *arg1 = (Ogre::PreApplyTextureAliasesScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AliasTextureNamePairList *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_Ogre__PreApplyTextureAliasesScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PreApplyTextureAliasesScriptCompilerEvent *","mAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PreApplyTextureAliasesScriptCompilerEvent * >(argp1);
  result = (Ogre::AliasTextureNamePairList *) ((arg1)->mAliases);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), 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, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PreApplyTextureAliasesScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::PreApplyTextureAliasesScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_PreApplyTextureAliasesScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::PreApplyTextureAliasesScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::PreApplyTextureAliasesScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PreApplyTextureAliasesScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = (Ogre::AliasTextureNamePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PreApplyTextureAliasesScriptCompilerEvent";
  Ogre::PreApplyTextureAliasesScriptCompilerEvent *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__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","Ogre::PreApplyTextureAliasesScriptCompilerEvent", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,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, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList *","Ogre::PreApplyTextureAliasesScriptCompilerEvent", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  result = (Ogre::PreApplyTextureAliasesScriptCompilerEvent *)new Ogre::PreApplyTextureAliasesScriptCompilerEvent(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PreApplyTextureAliasesScriptCompilerEvent(Ogre::PreApplyTextureAliasesScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassProcessResourceNameScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_ProcessResourceNameScriptCompilerEvent_mResourceType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessResourceNameScriptCompilerEvent *arg1 = (Ogre::ProcessResourceNameScriptCompilerEvent *) 0 ;
  Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ProcessResourceNameScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessResourceNameScriptCompilerEvent *","mResourceType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessResourceNameScriptCompilerEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType","mResourceType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType >(val2);
  if (arg1) (arg1)->mResourceType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessResourceNameScriptCompilerEvent_mResourceType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessResourceNameScriptCompilerEvent *arg1 = (Ogre::ProcessResourceNameScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType 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_Ogre__ProcessResourceNameScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessResourceNameScriptCompilerEvent *","mResourceType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessResourceNameScriptCompilerEvent * >(argp1);
  result = (Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType) ((arg1)->mResourceType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessResourceNameScriptCompilerEvent_mName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessResourceNameScriptCompilerEvent *arg1 = (Ogre::ProcessResourceNameScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__ProcessResourceNameScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessResourceNameScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessResourceNameScriptCompilerEvent * >(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( "", "Ogre::String const &","mName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessResourceNameScriptCompilerEvent_mName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessResourceNameScriptCompilerEvent *arg1 = (Ogre::ProcessResourceNameScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ProcessResourceNameScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessResourceNameScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessResourceNameScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessResourceNameScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ProcessResourceNameScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessResourceNameScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ProcessResourceNameScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::ProcessResourceNameScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ProcessResourceNameScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType arg1 ;
  Ogre::String *arg2 = 0 ;
  int val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::ProcessResourceNameScriptCompilerEvent";
  Ogre::ProcessResourceNameScriptCompilerEvent *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( "", "Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType","Ogre::ProcessResourceNameScriptCompilerEvent", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::ProcessResourceNameScriptCompilerEvent::ResourceType >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ProcessResourceNameScriptCompilerEvent", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ProcessResourceNameScriptCompilerEvent", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ProcessResourceNameScriptCompilerEvent *)new Ogre::ProcessResourceNameScriptCompilerEvent(arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_ProcessResourceNameScriptCompilerEvent(Ogre::ProcessResourceNameScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassProcessNameExclusionScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_ProcessNameExclusionScriptCompilerEvent_mClass_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessNameExclusionScriptCompilerEvent *arg1 = (Ogre::ProcessNameExclusionScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__ProcessNameExclusionScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessNameExclusionScriptCompilerEvent *","mClass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessNameExclusionScriptCompilerEvent * >(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( "", "Ogre::String const &","mClass", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mClass", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mClass = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessNameExclusionScriptCompilerEvent_mClass_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessNameExclusionScriptCompilerEvent *arg1 = (Ogre::ProcessNameExclusionScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ProcessNameExclusionScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessNameExclusionScriptCompilerEvent *","mClass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessNameExclusionScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mClass);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessNameExclusionScriptCompilerEvent_mParent_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessNameExclusionScriptCompilerEvent *arg1 = (Ogre::ProcessNameExclusionScriptCompilerEvent *) 0 ;
  Ogre::AbstractNode *arg2 = (Ogre::AbstractNode *) 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_Ogre__ProcessNameExclusionScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessNameExclusionScriptCompilerEvent *","mParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessNameExclusionScriptCompilerEvent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AbstractNode, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","mParent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNode * >(argp2);
  if (arg1) (arg1)->mParent = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessNameExclusionScriptCompilerEvent_mParent_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ProcessNameExclusionScriptCompilerEvent *arg1 = (Ogre::ProcessNameExclusionScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AbstractNode *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_Ogre__ProcessNameExclusionScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ProcessNameExclusionScriptCompilerEvent *","mParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ProcessNameExclusionScriptCompilerEvent * >(argp1);
  result = (Ogre::AbstractNode *) ((arg1)->mParent);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ProcessNameExclusionScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ProcessNameExclusionScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_ProcessNameExclusionScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ProcessNameExclusionScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::ProcessNameExclusionScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ProcessNameExclusionScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::AbstractNode *arg2 = (Ogre::AbstractNode *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ProcessNameExclusionScriptCompilerEvent";
  Ogre::ProcessNameExclusionScriptCompilerEvent *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::ProcessNameExclusionScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ProcessNameExclusionScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__AbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNode *","Ogre::ProcessNameExclusionScriptCompilerEvent", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNode * >(argp2);
  result = (Ogre::ProcessNameExclusionScriptCompilerEvent *)new Ogre::ProcessNameExclusionScriptCompilerEvent((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_ProcessNameExclusionScriptCompilerEvent(Ogre::ProcessNameExclusionScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassCreateMaterialScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_mFile_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateMaterialScriptCompilerEvent *arg1 = (Ogre::CreateMaterialScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateMaterialScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateMaterialScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateMaterialScriptCompilerEvent * >(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( "", "Ogre::String const &","mFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mFile = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_mFile_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateMaterialScriptCompilerEvent *arg1 = (Ogre::CreateMaterialScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateMaterialScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateMaterialScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateMaterialScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mFile);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_mName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateMaterialScriptCompilerEvent *arg1 = (Ogre::CreateMaterialScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateMaterialScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateMaterialScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateMaterialScriptCompilerEvent * >(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( "", "Ogre::String const &","mName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_mName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateMaterialScriptCompilerEvent *arg1 = (Ogre::CreateMaterialScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateMaterialScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateMaterialScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateMaterialScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_mResourceGroup_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateMaterialScriptCompilerEvent *arg1 = (Ogre::CreateMaterialScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateMaterialScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateMaterialScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateMaterialScriptCompilerEvent * >(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( "", "Ogre::String const &","mResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mResourceGroup = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_mResourceGroup_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateMaterialScriptCompilerEvent *arg1 = (Ogre::CreateMaterialScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateMaterialScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateMaterialScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateMaterialScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mResourceGroup);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateMaterialScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_CreateMaterialScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::CreateMaterialScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::CreateMaterialScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CreateMaterialScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::CreateMaterialScriptCompilerEvent";
  Ogre::CreateMaterialScriptCompilerEvent *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::CreateMaterialScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateMaterialScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateMaterialScriptCompilerEvent", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateMaterialScriptCompilerEvent", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateMaterialScriptCompilerEvent", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateMaterialScriptCompilerEvent", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::CreateMaterialScriptCompilerEvent *)new Ogre::CreateMaterialScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN void
free_Ogre_CreateMaterialScriptCompilerEvent(Ogre::CreateMaterialScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassCreateGpuProgramScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mFile_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mFile = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mFile_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mFile);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mResourceGroup_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mResourceGroup = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mResourceGroup_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mResourceGroup);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mSource_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mSource = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mSource_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mSource);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mSyntax_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mSyntax", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mSyntax", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mSyntax", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mSyntax = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mSyntax_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mSyntax", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mSyntax);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mProgramType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::GpuProgramType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mProgramType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","mProgramType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  if (arg1) (arg1)->mProgramType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_mProgramType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramType 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_Ogre__CreateGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuProgramScriptCompilerEvent *","mProgramType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::GpuProgramType) ((arg1)->mProgramType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateGpuProgramScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_CreateGpuProgramScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::CreateGpuProgramScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::CreateGpuProgramScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CreateGpuProgramScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::String *arg5 = 0 ;
  Ogre::GpuProgramType arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CreateGpuProgramScriptCompilerEvent";
  Ogre::CreateGpuProgramScriptCompilerEvent *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",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 &","Ogre::CreateGpuProgramScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 5, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuProgramScriptCompilerEvent", 5, argv[4])); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","Ogre::CreateGpuProgramScriptCompilerEvent", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::GpuProgramType >(val6);
  result = (Ogre::CreateGpuProgramScriptCompilerEvent *)new Ogre::CreateGpuProgramScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,(Ogre::String const &)*arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN void
free_Ogre_CreateGpuProgramScriptCompilerEvent(Ogre::CreateGpuProgramScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassCreateHighLevelGpuProgramScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mFile_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mFile = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mFile_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mFile);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mResourceGroup_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mResourceGroup = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mResourceGroup_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mResourceGroup);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mSource_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mSource", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mSource", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mSource = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mSource_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mSource", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mSource);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mLanguage_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mLanguage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(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( "", "Ogre::String const &","mLanguage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mLanguage", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mLanguage = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mLanguage_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mLanguage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mLanguage);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mProgramType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  Ogre::GpuProgramType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mProgramType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","mProgramType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GpuProgramType >(val2);
  if (arg1) (arg1)->mProgramType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mProgramType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1 = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramType 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_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *","mProgramType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateHighLevelGpuProgramScriptCompilerEvent * >(argp1);
  result = (Ogre::GpuProgramType) ((arg1)->mProgramType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateHighLevelGpuProgramScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::CreateHighLevelGpuProgramScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::CreateHighLevelGpuProgramScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CreateHighLevelGpuProgramScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::String *arg5 = 0 ;
  Ogre::GpuProgramType arg6 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int res5 = SWIG_OLDOBJ ;
  int val6 ;
  int ecode6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent";
  Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",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 &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[4], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 5, argv[4] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 5, argv[4])); 
    }
    arg5 = ptr;
  }
  ecode6 = SWIG_AsVal_int(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::GpuProgramType","Ogre::CreateHighLevelGpuProgramScriptCompilerEvent", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::GpuProgramType >(val6);
  result = (Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *)new Ogre::CreateHighLevelGpuProgramScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,(Ogre::String const &)*arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN void
free_Ogre_CreateHighLevelGpuProgramScriptCompilerEvent(Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassCreateGpuSharedParametersScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_mFile_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuSharedParametersScriptCompilerEvent *arg1 = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuSharedParametersScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuSharedParametersScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuSharedParametersScriptCompilerEvent * >(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( "", "Ogre::String const &","mFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mFile = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_mFile_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuSharedParametersScriptCompilerEvent *arg1 = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuSharedParametersScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuSharedParametersScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuSharedParametersScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mFile);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_mName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuSharedParametersScriptCompilerEvent *arg1 = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuSharedParametersScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuSharedParametersScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuSharedParametersScriptCompilerEvent * >(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( "", "Ogre::String const &","mName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_mName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuSharedParametersScriptCompilerEvent *arg1 = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuSharedParametersScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuSharedParametersScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuSharedParametersScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_mResourceGroup_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuSharedParametersScriptCompilerEvent *arg1 = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateGpuSharedParametersScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuSharedParametersScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuSharedParametersScriptCompilerEvent * >(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( "", "Ogre::String const &","mResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mResourceGroup = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_mResourceGroup_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateGpuSharedParametersScriptCompilerEvent *arg1 = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateGpuSharedParametersScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateGpuSharedParametersScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateGpuSharedParametersScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mResourceGroup);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateGpuSharedParametersScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_CreateGpuSharedParametersScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::CreateGpuSharedParametersScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::CreateGpuSharedParametersScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CreateGpuSharedParametersScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::CreateGpuSharedParametersScriptCompilerEvent";
  Ogre::CreateGpuSharedParametersScriptCompilerEvent *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::CreateGpuSharedParametersScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuSharedParametersScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateGpuSharedParametersScriptCompilerEvent", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuSharedParametersScriptCompilerEvent", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateGpuSharedParametersScriptCompilerEvent", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateGpuSharedParametersScriptCompilerEvent", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::CreateGpuSharedParametersScriptCompilerEvent *)new Ogre::CreateGpuSharedParametersScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN void
free_Ogre_CreateGpuSharedParametersScriptCompilerEvent(Ogre::CreateGpuSharedParametersScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassCreateParticleSystemScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_mFile_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateParticleSystemScriptCompilerEvent *arg1 = (Ogre::CreateParticleSystemScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateParticleSystemScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateParticleSystemScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateParticleSystemScriptCompilerEvent * >(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( "", "Ogre::String const &","mFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mFile = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_mFile_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateParticleSystemScriptCompilerEvent *arg1 = (Ogre::CreateParticleSystemScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateParticleSystemScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateParticleSystemScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateParticleSystemScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mFile);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_mName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateParticleSystemScriptCompilerEvent *arg1 = (Ogre::CreateParticleSystemScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateParticleSystemScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateParticleSystemScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateParticleSystemScriptCompilerEvent * >(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( "", "Ogre::String const &","mName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_mName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateParticleSystemScriptCompilerEvent *arg1 = (Ogre::CreateParticleSystemScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateParticleSystemScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateParticleSystemScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateParticleSystemScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_mResourceGroup_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateParticleSystemScriptCompilerEvent *arg1 = (Ogre::CreateParticleSystemScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateParticleSystemScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateParticleSystemScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateParticleSystemScriptCompilerEvent * >(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( "", "Ogre::String const &","mResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mResourceGroup = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_mResourceGroup_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateParticleSystemScriptCompilerEvent *arg1 = (Ogre::CreateParticleSystemScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateParticleSystemScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateParticleSystemScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateParticleSystemScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mResourceGroup);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateParticleSystemScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_CreateParticleSystemScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::CreateParticleSystemScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::CreateParticleSystemScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CreateParticleSystemScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::CreateParticleSystemScriptCompilerEvent";
  Ogre::CreateParticleSystemScriptCompilerEvent *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::CreateParticleSystemScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateParticleSystemScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateParticleSystemScriptCompilerEvent", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateParticleSystemScriptCompilerEvent", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateParticleSystemScriptCompilerEvent", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateParticleSystemScriptCompilerEvent", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::CreateParticleSystemScriptCompilerEvent *)new Ogre::CreateParticleSystemScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN void
free_Ogre_CreateParticleSystemScriptCompilerEvent(Ogre::CreateParticleSystemScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassCreateCompositorScriptCompilerEvent;

SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_mFile_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateCompositorScriptCompilerEvent *arg1 = (Ogre::CreateCompositorScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateCompositorScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateCompositorScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateCompositorScriptCompilerEvent * >(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( "", "Ogre::String const &","mFile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mFile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mFile = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_mFile_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateCompositorScriptCompilerEvent *arg1 = (Ogre::CreateCompositorScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateCompositorScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateCompositorScriptCompilerEvent *","mFile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateCompositorScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mFile);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_mName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateCompositorScriptCompilerEvent *arg1 = (Ogre::CreateCompositorScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateCompositorScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateCompositorScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateCompositorScriptCompilerEvent * >(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( "", "Ogre::String const &","mName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_mName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateCompositorScriptCompilerEvent *arg1 = (Ogre::CreateCompositorScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateCompositorScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateCompositorScriptCompilerEvent *","mName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateCompositorScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_mResourceGroup_set(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateCompositorScriptCompilerEvent *arg1 = (Ogre::CreateCompositorScriptCompilerEvent *) 0 ;
  Ogre::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_Ogre__CreateCompositorScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateCompositorScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateCompositorScriptCompilerEvent * >(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( "", "Ogre::String const &","mResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","mResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->mResourceGroup = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_mResourceGroup_get(int argc, VALUE *argv, VALUE self) {
  Ogre::CreateCompositorScriptCompilerEvent *arg1 = (Ogre::CreateCompositorScriptCompilerEvent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__CreateCompositorScriptCompilerEvent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CreateCompositorScriptCompilerEvent *","mResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CreateCompositorScriptCompilerEvent * >(argp1);
  result = (Ogre::String *) & ((arg1)->mResourceGroup);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_eventType_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::CreateCompositorScriptCompilerEvent::eventType));
  return _val;
}


SWIGINTERN VALUE
_wrap_CreateCompositorScriptCompilerEvent_eventType_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::CreateCompositorScriptCompilerEvent::eventType""' of type '""Ogre::String""'"); 
    }
    Ogre::CreateCompositorScriptCompilerEvent::eventType = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_CreateCompositorScriptCompilerEvent(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::CreateCompositorScriptCompilerEvent";
  Ogre::CreateCompositorScriptCompilerEvent *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::CreateCompositorScriptCompilerEvent", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateCompositorScriptCompilerEvent", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateCompositorScriptCompilerEvent", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateCompositorScriptCompilerEvent", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::CreateCompositorScriptCompilerEvent", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::CreateCompositorScriptCompilerEvent", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::CreateCompositorScriptCompilerEvent *)new Ogre::CreateCompositorScriptCompilerEvent((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN void
free_Ogre_CreateCompositorScriptCompilerEvent(Ogre::CreateCompositorScriptCompilerEvent *arg1) {
    delete arg1;
}

swig_class SwigClassParticleSystem;

SWIGINTERN VALUE
_wrap_new_ParticleSystem__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ParticleSystem";
  Ogre::ParticleSystem *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleSystem *)new Ogre::ParticleSystem();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ParticleSystem__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::ParticleSystem";
  Ogre::ParticleSystem *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::ParticleSystem", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ParticleSystem", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ParticleSystem", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ParticleSystem", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleSystem *)new Ogre::ParticleSystem((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ParticleSystem(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_ParticleSystem__SWIG_0(nargs, args, self);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_new_ParticleSystem__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "ParticleSystem.new", 
    "    ParticleSystem.new()\n"
    "    ParticleSystem.new(Ogre::String const &name, Ogre::String const &resourceGroupName)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleSystem(Ogre::ParticleSystem *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleSystem_setRenderer(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setRenderer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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( "", "Ogre::String const &","setRenderer", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setRenderer", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setRenderer((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getRenderer(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParticleSystemRenderer *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getRenderer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::ParticleSystemRenderer *)((Ogre::ParticleSystem const *)arg1)->getRenderer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getRendererName(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getRendererName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getRendererName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_addEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ParticleEmitter *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","addEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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( "", "Ogre::String const &","addEmitter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addEmitter", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleEmitter *)(arg1)->addEmitter((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::ParticleEmitter *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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","getEmitter", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::ParticleEmitter *)((Ogre::ParticleSystem const *)arg1)->getEmitter(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getNumEmitters(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getNumEmitters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (unsigned short)((Ogre::ParticleSystem const *)arg1)->getNumEmitters();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_removeEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","removeEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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","removeEmitter", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removeEmitter(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_removeAllEmitters(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","removeAllEmitters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  (arg1)->removeAllEmitters();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_addAffector(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ParticleAffector *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","addAffector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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( "", "Ogre::String const &","addAffector", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addAffector", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleAffector *)(arg1)->addAffector((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getAffector(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::ParticleAffector *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getAffector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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","getAffector", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::ParticleAffector *)((Ogre::ParticleSystem const *)arg1)->getAffector(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getNumAffectors(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getNumAffectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (unsigned short)((Ogre::ParticleSystem const *)arg1)->getNumAffectors();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_removeAffector(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","removeAffector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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","removeAffector", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removeAffector(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_removeAllAffectors(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","removeAllAffectors", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  (arg1)->removeAllAffectors();
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ParticleSystem.clear

  call-seq:
    clear

Clear ParticleSystem contents.
*/
SWIGINTERN VALUE
_wrap_ParticleSystem_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getNumParticles(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getNumParticles", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = ((Ogre::ParticleSystem const *)arg1)->getNumParticles();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_createParticle(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Particle *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","createParticle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::Particle *)(arg1)->createParticle();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_createEmitterParticle(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Particle *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","createEmitterParticle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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( "", "Ogre::String const &","createEmitterParticle", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEmitterParticle", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Particle *)(arg1)->createEmitterParticle((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getParticle(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::Particle *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","getParticle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getParticle", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Particle *)(arg1)->getParticle(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Particle, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getParticleQuota(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getParticleQuota", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = ((Ogre::ParticleSystem const *)arg1)->getParticleQuota();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setParticleQuota(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setParticleQuota", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setParticleQuota", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setParticleQuota(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getEmittedEmitterQuota(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getEmittedEmitterQuota", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = ((Ogre::ParticleSystem const *)arg1)->getEmittedEmitterQuota();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setEmittedEmitterQuota(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setEmittedEmitterQuota", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setEmittedEmitterQuota", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setEmittedEmitterQuota(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__update(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_update", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->_update(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__getIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ParticleIterator > 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_getIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (arg1)->_getIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ParticleIterator(static_cast< const Ogre::ParticleIterator& >(result))), SWIGTYPE_p_Ogre__ParticleIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setMaterialName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setMaterialName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_setMaterialName(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_Ogre__ParticleSystem, 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_ParticleSystem_setMaterialName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystem, 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_ParticleSystem_setMaterialName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.setMaterialName", 
    "    void ParticleSystem.setMaterialName(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void ParticleSystem.setMaterialName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__notifyCurrentCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_notifyCurrentCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_notifyCurrentCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_notifyCurrentCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__notifyAttached__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAttached", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAttached(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__notifyAttached__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem__notifyAttached(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_Ogre__ParticleSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleSystem__notifyAttached__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleSystem__notifyAttached__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem._notifyAttached", 
    "    void ParticleSystem._notifyAttached(Ogre::Node *parent, bool isTagPoint)\n"
    "    void ParticleSystem._notifyAttached(Ogre::Node *parent)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::ParticleSystem const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__updateRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_updateRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_updateRenderQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_updateRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_visitRenderables(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_Ogre__ParticleSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ParticleSystem_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleSystem_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.visitRenderables", 
    "    void ParticleSystem.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void ParticleSystem.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_fastForward__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","fastForward", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","fastForward", 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","fastForward", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->fastForward(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_fastForward__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","fastForward", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","fastForward", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->fastForward(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_fastForward(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_Ogre__ParticleSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleSystem_fastForward__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystem, 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_ParticleSystem_fastForward__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.fastForward", 
    "    void ParticleSystem.fastForward(Ogre::Real time, Ogre::Real interval)\n"
    "    void ParticleSystem.fastForward(Ogre::Real time)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setSpeedFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setSpeedFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpeedFactor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSpeedFactor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getSpeedFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getSpeedFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getSpeedFactor();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setIterationInterval(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setIterationInterval", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setIterationInterval", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setIterationInterval(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getIterationInterval(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getIterationInterval", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getIterationInterval();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setDefaultIterationInterval(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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","Ogre::ParticleSystem::setDefaultIterationInterval", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  Ogre::ParticleSystem::setDefaultIterationInterval(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getDefaultIterationInterval(int argc, VALUE *argv, VALUE self) {
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Real)Ogre::ParticleSystem::getDefaultIterationInterval();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setNonVisibleUpdateTimeout(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setNonVisibleUpdateTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setNonVisibleUpdateTimeout", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setNonVisibleUpdateTimeout(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getNonVisibleUpdateTimeout(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getNonVisibleUpdateTimeout", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getNonVisibleUpdateTimeout();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setDefaultNonVisibleUpdateTimeout(int argc, VALUE *argv, VALUE self) {
  Ogre::Real arg1 ;
  float val1 ;
  int ecode1 = 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","Ogre::ParticleSystem::setDefaultNonVisibleUpdateTimeout", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Real >(val1);
  Ogre::ParticleSystem::setDefaultNonVisibleUpdateTimeout(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getDefaultNonVisibleUpdateTimeout(int argc, VALUE *argv, VALUE self) {
  Ogre::Real result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Real)Ogre::ParticleSystem::getDefaultNonVisibleUpdateTimeout();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__notifyParticleResized(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_notifyParticleResized", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  (arg1)->_notifyParticleResized();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__notifyParticleRotated(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_notifyParticleRotated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  (arg1)->_notifyParticleRotated();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setDefaultDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setDefaultDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultDimensions", 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","setDefaultDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setDefaultDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setDefaultWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setDefaultWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDefaultWidth(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getDefaultWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getDefaultWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getDefaultWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setDefaultHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setDefaultHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultHeight", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDefaultHeight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getDefaultHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getDefaultHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleSystem const *)arg1)->getDefaultHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getCullIndividually(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getCullIndividually", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (bool)((Ogre::ParticleSystem const *)arg1)->getCullIndividually();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setCullIndividually(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setCullIndividually", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCullIndividually", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCullIndividually(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getResourceGroupName(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getResourceGroupName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getResourceGroupName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleSystem const *)arg1)->getOrigin();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__notifyOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_notifyOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(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( "", "Ogre::String const &","_notifyOrigin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_notifyOrigin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->_notifyOrigin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setSortingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setSortingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSortingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSortingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getSortingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getSortingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (bool)((Ogre::ParticleSystem const *)arg1)->getSortingEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","setBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","setBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->setBounds((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setBoundsAutoUpdated__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  bool arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setBoundsAutoUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBoundsAutoUpdated", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setBoundsAutoUpdated", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setBoundsAutoUpdated(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setBoundsAutoUpdated__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setBoundsAutoUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBoundsAutoUpdated", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBoundsAutoUpdated(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystem_setBoundsAutoUpdated(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_Ogre__ParticleSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleSystem_setBoundsAutoUpdated__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystem, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_ParticleSystem_setBoundsAutoUpdated__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystem.setBoundsAutoUpdated", 
    "    void ParticleSystem.setBoundsAutoUpdated(bool autoUpdate, Ogre::Real stopIn)\n"
    "    void ParticleSystem.setBoundsAutoUpdated(bool autoUpdate)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setKeepParticlesInLocalSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setKeepParticlesInLocalSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setKeepParticlesInLocalSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setKeepParticlesInLocalSpace(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getKeepParticlesInLocalSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getKeepParticlesInLocalSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (bool)((Ogre::ParticleSystem const *)arg1)->getKeepParticlesInLocalSpace();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem__updateBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_updateBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  (arg1)->_updateBounds();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_setEmitting(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","setEmitting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEmitting", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEmitting(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getEmitting(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getEmitting", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (bool)((Ogre::ParticleSystem const *)arg1)->getEmitting();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystem_getTypeFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystem *arg1 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystem const *","getTypeFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystem * >(argp1);
  result = (Ogre::uint32)((Ogre::ParticleSystem const *)arg1)->getTypeFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassParticleSystemManager;

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

SWIGINTERN VALUE
_wrap_new_ParticleSystemManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ParticleSystemManager";
  Ogre::ParticleSystemManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleSystemManager *)new Ogre::ParticleSystemManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleSystemManager(Ogre::ParticleSystemManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleSystemManager_addEmitterFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::ParticleEmitterFactory *arg2 = (Ogre::ParticleEmitterFactory *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","addEmitterFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleEmitterFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleEmitterFactory *","addEmitterFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleEmitterFactory * >(argp2);
  (arg1)->addEmitterFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_addAffectorFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::ParticleAffectorFactory *arg2 = (Ogre::ParticleAffectorFactory *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","addAffectorFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleAffectorFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleAffectorFactory *","addAffectorFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleAffectorFactory * >(argp2);
  (arg1)->addAffectorFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_addRendererFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::ParticleSystemRendererFactory *arg2 = (Ogre::ParticleSystemRendererFactory *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","addRendererFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystemRendererFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRendererFactory *","addRendererFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystemRendererFactory * >(argp2);
  (arg1)->addRendererFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_addTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ParticleSystem *arg3 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","addTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","addTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addTemplate", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","addTemplate", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ParticleSystem * >(argp3);
  (arg1)->addTemplate((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_removeTemplate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","removeTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","removeTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeTemplate", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","removeTemplate", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->removeTemplate((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_removeTemplate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","removeTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","removeTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeTemplate", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeTemplate((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemManager_removeTemplate(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_Ogre__ParticleSystemManager, 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_ParticleSystemManager_removeTemplate__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystemManager, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ParticleSystemManager_removeTemplate__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ParticleSystemManager.removeTemplate", 
    "    void ParticleSystemManager.removeTemplate(Ogre::String const &name, bool deleteTemplate)\n"
    "    void ParticleSystemManager.removeTemplate(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_removeAllTemplates__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","removeAllTemplates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","removeAllTemplates", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->removeAllTemplates(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_removeAllTemplates__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","removeAllTemplates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  (arg1)->removeAllTemplates();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ParticleSystemManager_removeAllTemplates(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_Ogre__ParticleSystemManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ParticleSystemManager_removeAllTemplates__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ParticleSystemManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ParticleSystemManager_removeAllTemplates__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ParticleSystemManager.removeAllTemplates", 
    "    void ParticleSystemManager.removeAllTemplates(bool deleteTemplate)\n"
    "    void ParticleSystemManager.removeAllTemplates()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_removeTemplatesByResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","removeTemplatesByResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","removeTemplatesByResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeTemplatesByResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeTemplatesByResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_createTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::ParticleSystem *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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","createTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","createTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createTemplate", 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 &","createTemplate", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createTemplate", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::ParticleSystem *)(arg1)->createTemplate((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  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_ParticleSystemManager_getTemplate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ParticleSystem *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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","getTemplate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","getTemplate", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTemplate", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleSystem *)(arg1)->getTemplate((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__createEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ParticleSystem *arg3 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::ParticleEmitter *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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_createEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","_createEmitter", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_createEmitter", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_createEmitter", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ParticleSystem * >(argp3);
  result = (Ogre::ParticleEmitter *)(arg1)->_createEmitter((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__destroyEmitter(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::ParticleEmitter *arg2 = (Ogre::ParticleEmitter *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_destroyEmitter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleEmitter, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleEmitter *","_destroyEmitter", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleEmitter * >(argp2);
  (arg1)->_destroyEmitter(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__createAffector(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ParticleSystem *arg3 = (Ogre::ParticleSystem *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::ParticleAffector *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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_createAffector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","_createAffector", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_createAffector", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","_createAffector", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ParticleSystem * >(argp3);
  result = (Ogre::ParticleAffector *)(arg1)->_createAffector((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__destroyAffector(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::ParticleAffector *arg2 = (Ogre::ParticleAffector *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_destroyAffector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleAffector, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleAffector *","_destroyAffector", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleAffector * >(argp2);
  (arg1)->_destroyAffector(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__createRenderer(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ParticleSystemRenderer *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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_createRenderer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(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( "", "Ogre::String const &","_createRenderer", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_createRenderer", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleSystemRenderer *)(arg1)->_createRenderer((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__destroyRenderer(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::ParticleSystemRenderer *arg2 = (Ogre::ParticleSystemRenderer *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_destroyRenderer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystemRenderer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystemRenderer *","_destroyRenderer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystemRenderer * >(argp2);
  (arg1)->_destroyRenderer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  (arg1)->_initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getScriptPatterns(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StringVector *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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager const *","getScriptPatterns", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  result = (Ogre::StringVector *) &((Ogre::ParticleSystemManager const *)arg1)->getScriptPatterns();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","parseScript", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseScript", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseScript(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getLoadingOrder(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager const *","getLoadingOrder", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  result = (Ogre::Real)((Ogre::ParticleSystemManager const *)arg1)->getLoadingOrder();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getAffectorFactoryIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleAffectorFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleAffectorFactory * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","getAffectorFactoryIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  result = (arg1)->getAffectorFactoryIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ParticleSystemManager::ParticleAffectorFactoryIterator(static_cast< const Ogre::ParticleSystemManager::ParticleAffectorFactoryIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getEmitterFactoryIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleEmitterFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleEmitterFactory * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","getEmitterFactoryIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  result = (arg1)->getEmitterFactoryIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ParticleSystemManager::ParticleEmitterFactoryIterator(static_cast< const Ogre::ParticleSystemManager::ParticleEmitterFactoryIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getRendererFactoryIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleSystemRendererFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleSystemRendererFactory * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","getRendererFactoryIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  result = (arg1)->getRendererFactoryIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ParticleSystemManager::ParticleRendererFactoryIterator(static_cast< const Ogre::ParticleSystemManager::ParticleRendererFactoryIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getTemplateIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleSystem *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleSystem * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","getTemplateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  result = (arg1)->getTemplateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ParticleSystemManager::ParticleSystemTemplateIterator(static_cast< const Ogre::ParticleSystemManager::ParticleSystemTemplateIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager__getFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *arg1 = (Ogre::ParticleSystemManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParticleSystemFactory *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_Ogre__ParticleSystemManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemManager *","_getFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemManager * >(argp1);
  result = (Ogre::ParticleSystemFactory *)(arg1)->_getFactory();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemFactory, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleSystemManager *) &Ogre::ParticleSystemManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleSystemManager *)Ogre::ParticleSystemManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystemManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassParticleSystemFactory;

SWIGINTERN void
free_Ogre_ParticleSystemFactory(Ogre::ParticleSystemFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ParticleSystemFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ParticleSystemFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_ParticleSystemFactory_FACTORY_TYPE_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ParticleSystemFactory::FACTORY_TYPE_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::ParticleSystemFactory::FACTORY_TYPE_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemFactory *arg1 = (Ogre::ParticleSystemFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ParticleSystemFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::ParticleSystemFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemFactory *arg1 = (Ogre::ParticleSystemFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__ParticleSystemFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPass;

SWIGINTERN VALUE
_wrap_new_Pass__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Pass";
  Ogre::Pass *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__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","Ogre::Pass", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::Pass", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Pass *)new Ogre::Pass(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Pass__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  unsigned short arg2 ;
  Ogre::Pass *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Pass";
  Ogre::Pass *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","Ogre::Pass", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned short","Ogre::Pass", 2, argv[1] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__Pass,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass const &","Ogre::Pass", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Pass const &","Ogre::Pass", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  result = (Ogre::Pass *)new Ogre::Pass(arg1,arg2,(Ogre::Pass const &)*arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Pass(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 == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_Pass__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_Pass__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Pass.new", 
    "    Pass.new(Ogre::Technique *parent, unsigned short index)\n"
    "    Pass.new(Ogre::Technique *parent, unsigned short index, Ogre::Pass const &oth)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Pass(Ogre::Pass *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Pass_isProgrammable(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","isProgrammable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->isProgrammable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasVertexProgram();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasFragmentProgram();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasGeometryProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasGeometryProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasGeometryProgram();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasShadowCasterVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasShadowCasterVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasShadowCasterVertexProgram();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasShadowCasterFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasShadowCasterFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasShadowCasterFragmentProgram();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasShadowReceiverVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasShadowReceiverVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasShadowReceiverVertexProgram();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasShadowReceiverFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasShadowReceiverFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasShadowReceiverFragmentProgram();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (unsigned short)((Ogre::Pass const *)arg1)->getIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setAmbient__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setAmbient", 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","setAmbient", 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","setAmbient", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setAmbient(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setAmbient__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setAmbient", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setAmbient", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setAmbient(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pass_setAmbient__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_Pass_setAmbient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.setAmbient", 
    "    void Pass.setAmbient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Pass.setAmbient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setDiffuse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDiffuse", 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","setDiffuse", 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","setDiffuse", 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","setDiffuse", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setDiffuse(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setDiffuse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setDiffuse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setDiffuse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setDiffuse(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pass_setDiffuse__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Pass_setDiffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.setDiffuse", 
    "    void Pass.setDiffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Pass.setDiffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSpecular__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpecular", 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","setSpecular", 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","setSpecular", 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","setSpecular", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setSpecular(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSpecular__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSpecular", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSpecular", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setSpecular(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pass_setSpecular__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Pass_setSpecular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.setSpecular", 
    "    void Pass.setSpecular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Pass.setSpecular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShininess(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShininess", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShininess", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShininess(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSelfIllumination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSelfIllumination", 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","setSelfIllumination", 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","setSelfIllumination", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setSelfIllumination(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setEmissive__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setEmissive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setEmissive", 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","setEmissive", 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","setEmissive", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setEmissive(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSelfIllumination__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setSelfIllumination(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pass_setSelfIllumination__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_Pass_setSelfIllumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.setSelfIllumination", 
    "    void Pass.setSelfIllumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Pass.setSelfIllumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setEmissive__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setEmissive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setEmissive", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setEmissive", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setEmissive((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setEmissive(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pass_setEmissive__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_Pass_setEmissive__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.setEmissive", 
    "    void Pass.setEmissive(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Pass.setEmissive(Ogre::ColourValue const &emissive)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setVertexColourTracking(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::TrackVertexColourType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setVertexColourTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TrackVertexColourType","setVertexColourTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TrackVertexColourType >(val2);
  (arg1)->setVertexColourTracking(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPointSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPointSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPointSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setPointSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointSpritesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointSpritesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPointSpritesEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPointSpritesEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPointSpritesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPointSpritesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getPointSpritesEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointAttenuation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointAttenuation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPointAttenuation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPointAttenuation", 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","setPointAttenuation", 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","setPointAttenuation", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setPointAttenuation(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointAttenuation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointAttenuation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPointAttenuation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPointAttenuation", 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","setPointAttenuation", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setPointAttenuation(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointAttenuation__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointAttenuation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPointAttenuation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setPointAttenuation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setPointAttenuation(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointAttenuation__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointAttenuation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPointAttenuation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPointAttenuation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setPointAttenuation(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pass_setPointAttenuation__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Pass_setPointAttenuation__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Pass_setPointAttenuation__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Pass_setPointAttenuation__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.setPointAttenuation", 
    "    void Pass.setPointAttenuation(bool enabled, Ogre::Real constant, Ogre::Real linear, Ogre::Real quadratic)\n"
    "    void Pass.setPointAttenuation(bool enabled, Ogre::Real constant, Ogre::Real linear)\n"
    "    void Pass.setPointAttenuation(bool enabled, Ogre::Real constant)\n"
    "    void Pass.setPointAttenuation(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_isPointAttenuationEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","isPointAttenuationEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->isPointAttenuationEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPointAttenuationConstant(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPointAttenuationConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointAttenuationConstant();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPointAttenuationLinear(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPointAttenuationLinear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointAttenuationLinear();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPointAttenuationQuadratic(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPointAttenuationQuadratic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointAttenuationQuadratic();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointMinSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointMinSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPointMinSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setPointMinSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPointMinSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPointMinSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointMinSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPointMaxSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPointMaxSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPointMaxSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setPointMaxSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPointMaxSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPointMaxSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getPointMaxSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getAmbient(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getAmbient();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDiffuse(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getDiffuse();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getSpecular(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getSpecular();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getSelfIllumination(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getSelfIllumination();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getEmissive(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getEmissive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getEmissive();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShininess(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShininess", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getShininess();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getVertexColourTracking(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TrackVertexColourType 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getVertexColourTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::TrackVertexColourType)((Ogre::Pass const *)arg1)->getVertexColourTracking();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_createTextureUnitState__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureUnitState *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","createTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::TextureUnitState *)(arg1)->createTextureUnitState();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_createTextureUnitState__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::TextureUnitState *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","createTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","createTextureUnitState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createTextureUnitState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","createTextureUnitState", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = (Ogre::TextureUnitState *)(arg1)->createTextureUnitState((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_createTextureUnitState__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::TextureUnitState *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","createTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","createTextureUnitState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createTextureUnitState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::TextureUnitState *)(arg1)->createTextureUnitState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_createTextureUnitState(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pass_createTextureUnitState__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_Pass_createTextureUnitState__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pass_createTextureUnitState__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.createTextureUnitState", 
    "    Ogre::TextureUnitState * Pass.createTextureUnitState()\n"
    "    Ogre::TextureUnitState * Pass.createTextureUnitState(Ogre::String const &textureName, unsigned short texCoordSet)\n"
    "    Ogre::TextureUnitState * Pass.createTextureUnitState(Ogre::String const &textureName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_addTextureUnitState(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","addTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState *","addTextureUnitState", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  (arg1)->addTextureUnitState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTextureUnitState__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::TextureUnitState *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","getTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","getTextureUnitState", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::TextureUnitState *)(arg1)->getTextureUnitState(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTextureUnitState__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::TextureUnitState *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","getTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","getTextureUnitState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTextureUnitState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::TextureUnitState *)(arg1)->getTextureUnitState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTextureUnitState__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::TextureUnitState *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","getTextureUnitState", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::TextureUnitState *)((Ogre::Pass const *)arg1)->getTextureUnitState(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTextureUnitState__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::TextureUnitState *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","getTextureUnitState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getTextureUnitState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::TextureUnitState *)((Ogre::Pass const *)arg1)->getTextureUnitState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_getTextureUnitState(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pass_getTextureUnitState__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pass_getTextureUnitState__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_Pass_getTextureUnitState__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_Pass_getTextureUnitState__SWIG_3(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Pass.getTextureUnitState", 
    "    Ogre::TextureUnitState const * Pass.getTextureUnitState(unsigned short index)\n"
    "    Ogre::TextureUnitState const * Pass.getTextureUnitState(Ogre::String const &name)\n"
    "    Ogre::TextureUnitState const * Pass.getTextureUnitState(unsigned short index)\n"
    "    Ogre::TextureUnitState const * Pass.getTextureUnitState(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTextureUnitStateIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::TextureUnitState *arg2 = (Ogre::TextureUnitState *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getTextureUnitStateIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TextureUnitState, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState const *","getTextureUnitStateIndex", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TextureUnitState * >(argp2);
  result = (unsigned short)((Ogre::Pass const *)arg1)->getTextureUnitStateIndex((Ogre::TextureUnitState const *)arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTextureUnitStateIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::TextureUnitState *,Ogre::STLAllocator< Ogre::TextureUnitState *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","getTextureUnitStateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (arg1)->getTextureUnitStateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Pass::TextureUnitStateIterator(static_cast< const Ogre::Pass::TextureUnitStateIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTextureUnitStateIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::TextureUnitState *,Ogre::STLAllocator< Ogre::TextureUnitState *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getTextureUnitStateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getTextureUnitStateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Pass::ConstTextureUnitStateIterator(static_cast< const Ogre::Pass::ConstTextureUnitStateIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_getTextureUnitStateIterator(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pass_getTextureUnitStateIterator__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pass_getTextureUnitStateIterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pass.getTextureUnitStateIterator", 
    "    Ogre::Pass::ConstTextureUnitStateIterator Pass.getTextureUnitStateIterator()\n"
    "    Ogre::Pass::ConstTextureUnitStateIterator Pass.getTextureUnitStateIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_removeTextureUnitState(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","removeTextureUnitState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","removeTextureUnitState", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removeTextureUnitState(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_removeAllTextureUnitStates(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","removeAllTextureUnitStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->removeAllTextureUnitStates();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getNumTextureUnitStates(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getNumTextureUnitStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (unsigned short)((Ogre::Pass const *)arg1)->getNumTextureUnitStates();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::SceneBlendType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  (arg1)->setSceneBlending(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSeparateSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::SceneBlendType arg2 ;
  Ogre::SceneBlendType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendType >(val3);
  (arg1)->setSeparateSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  (arg1)->setSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setSceneBlending(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pass_setSceneBlending__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _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_Pass_setSceneBlending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.setSceneBlending", 
    "    void Pass.setSceneBlending(Ogre::SceneBlendType const sbt)\n"
    "    void Pass.setSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSeparateSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendFactor arg4 ;
  Ogre::SceneBlendFactor arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendFactor >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::SceneBlendFactor >(val5);
  (arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setSeparateSceneBlending(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_Ogre__Pass, 0);
    _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_Pass_setSeparateSceneBlending__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _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) {
          {
            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_Pass_setSeparateSceneBlending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Pass.setSeparateSceneBlending", 
    "    void Pass.setSeparateSceneBlending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Pass.setSeparateSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasSeparateSceneBlending(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasSeparateSceneBlending();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getSourceBlendFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendFactor 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getSourceBlendFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getSourceBlendFactor();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDestBlendFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendFactor 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDestBlendFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getDestBlendFactor();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getSourceBlendFactorAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendFactor 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getSourceBlendFactorAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getSourceBlendFactorAlpha();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDestBlendFactorAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendFactor 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDestBlendFactorAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::SceneBlendFactor)((Ogre::Pass const *)arg1)->getDestBlendFactorAlpha();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSceneBlendingOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::SceneBlendOperation arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSceneBlendingOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendOperation","setSceneBlendingOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendOperation >(val2);
  (arg1)->setSceneBlendingOperation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setSeparateSceneBlendingOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::SceneBlendOperation arg2 ;
  Ogre::SceneBlendOperation arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setSeparateSceneBlendingOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendOperation","setSeparateSceneBlendingOperation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendOperation >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendOperation","setSeparateSceneBlendingOperation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendOperation >(val3);
  (arg1)->setSeparateSceneBlendingOperation(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_hasSeparateSceneBlendingOperations(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","hasSeparateSceneBlendingOperations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->hasSeparateSceneBlendingOperations();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getSceneBlendingOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendOperation 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getSceneBlendingOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::SceneBlendOperation)((Ogre::Pass const *)arg1)->getSceneBlendingOperation();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getSceneBlendingOperationAlpha(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneBlendOperation 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getSceneBlendingOperationAlpha", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::SceneBlendOperation)((Ogre::Pass const *)arg1)->getSceneBlendingOperationAlpha();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_isTransparent(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","isTransparent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->isTransparent();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setDepthCheckEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setDepthCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthCheckEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDepthCheckEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDepthCheckEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDepthCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getDepthCheckEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setDepthWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setDepthWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDepthWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDepthWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDepthWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getDepthWriteEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setDepthFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setDepthFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setDepthFunction", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (arg1)->setDepthFunction(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDepthFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompareFunction 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDepthFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::CompareFunction)((Ogre::Pass const *)arg1)->getDepthFunction();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setColourWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setColourWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setColourWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setColourWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getColourWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getColourWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getColourWriteEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::CullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CullingMode","setCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CullingMode >(val2);
  (arg1)->setCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CullingMode 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::CullingMode)((Ogre::Pass const *)arg1)->getCullingMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setManualCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::ManualCullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setManualCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ManualCullingMode","setManualCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ManualCullingMode >(val2);
  (arg1)->setManualCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getManualCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ManualCullingMode 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getManualCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ManualCullingMode)((Ogre::Pass const *)arg1)->getManualCullingMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setLightingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setLightingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLightingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLightingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getLightingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getLightingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getLightingEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setMaxSimultaneousLights(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setMaxSimultaneousLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","setMaxSimultaneousLights", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setMaxSimultaneousLights(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getMaxSimultaneousLights(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getMaxSimultaneousLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (unsigned short)((Ogre::Pass const *)arg1)->getMaxSimultaneousLights();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setStartLight(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setStartLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","setStartLight", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setStartLight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getStartLight(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getStartLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (unsigned short)((Ogre::Pass const *)arg1)->getStartLight();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setLightMask(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::uint32 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setLightMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setLightMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setLightMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getLightMask(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getLightMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::uint32)((Ogre::Pass const *)arg1)->getLightMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::ShadeOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadeOptions","setShadingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadeOptions >(val2);
  (arg1)->setShadingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ShadeOptions 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ShadeOptions)((Ogre::Pass const *)arg1)->getShadingMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPolygonMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::PolygonMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPolygonMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PolygonMode","setPolygonMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PolygonMode >(val2);
  (arg1)->setPolygonMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPolygonMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PolygonMode 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPolygonMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::PolygonMode)((Ogre::Pass const *)arg1)->getPolygonMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPolygonModeOverrideable(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPolygonModeOverrideable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPolygonModeOverrideable", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPolygonModeOverrideable(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPolygonModeOverrideable(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPolygonModeOverrideable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getPolygonModeOverrideable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFog__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFog__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  (arg1)->setFog(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFog__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFog(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setFog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pass_setFog__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Pass_setFog__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Pass_setFog__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Pass_setFog__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Pass_setFog__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Pass_setFog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Pass.setFog", 
    "    void Pass.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Pass.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Pass.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Pass.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Pass.setFog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Pass.setFog(bool overrideScene)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFogOverride(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFogOverride", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getFogOverride();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFogMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::FogMode 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFogMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::FogMode)((Ogre::Pass const *)arg1)->getFogMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFogColour(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFogColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::Pass const *)arg1)->getFogColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFogStart(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFogStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getFogStart();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFogEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFogEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getFogEnd();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFogDensity(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFogDensity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Real)((Ogre::Pass const *)arg1)->getFogDensity();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setDepthBias__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setDepthBias", 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","setDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setDepthBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setDepthBias__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setDepthBias", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setDepthBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setDepthBias(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pass_setDepthBias__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_Pass_setDepthBias__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.setDepthBias", 
    "    void Pass.setDepthBias(float constantBias, float slopeScaleBias)\n"
    "    void Pass.setDepthBias(float constantBias)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDepthBiasConstant(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDepthBiasConstant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (float)((Ogre::Pass const *)arg1)->getDepthBiasConstant();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDepthBiasSlopeScale(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getDepthBiasSlopeScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (float)((Ogre::Pass const *)arg1)->getDepthBiasSlopeScale();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setIterationDepthBias(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setIterationDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setIterationDepthBias", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setIterationDepthBias(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getIterationDepthBias(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getIterationDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (float)((Ogre::Pass const *)arg1)->getIterationDepthBias();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setAlphaRejectSettings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::CompareFunction arg2 ;
  unsigned char arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setAlphaRejectSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setAlphaRejectSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned char","setAlphaRejectSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned char >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","setAlphaRejectSettings", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->setAlphaRejectSettings(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setAlphaRejectSettings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::CompareFunction arg2 ;
  unsigned char arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setAlphaRejectSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setAlphaRejectSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned char","setAlphaRejectSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned char >(val3);
  (arg1)->setAlphaRejectSettings(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setAlphaRejectSettings(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pass_setAlphaRejectSettings__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Pass_setAlphaRejectSettings__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.setAlphaRejectSettings", 
    "    void Pass.setAlphaRejectSettings(Ogre::CompareFunction func, unsigned char value, bool alphaToCoverageEnabled)\n"
    "    void Pass.setAlphaRejectSettings(Ogre::CompareFunction func, unsigned char value)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setAlphaRejectFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setAlphaRejectFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setAlphaRejectFunction", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (arg1)->setAlphaRejectFunction(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setAlphaRejectValue(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned char arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setAlphaRejectValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","setAlphaRejectValue", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned char >(val2);
  (arg1)->setAlphaRejectValue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getAlphaRejectFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompareFunction 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getAlphaRejectFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::CompareFunction)((Ogre::Pass const *)arg1)->getAlphaRejectFunction();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getAlphaRejectValue(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getAlphaRejectValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (unsigned char)((Ogre::Pass const *)arg1)->getAlphaRejectValue();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setAlphaToCoverageEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setAlphaToCoverageEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAlphaToCoverageEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAlphaToCoverageEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_isAlphaToCoverageEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","isAlphaToCoverageEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->isAlphaToCoverageEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setTransparentSortingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setTransparentSortingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTransparentSortingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTransparentSortingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTransparentSortingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getTransparentSortingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getTransparentSortingEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setTransparentSortingForced(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setTransparentSortingForced", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setTransparentSortingForced", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setTransparentSortingForced(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getTransparentSortingForced(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getTransparentSortingForced", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getTransparentSortingForced();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setIteratePerLight__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  bool arg3 ;
  Ogre::Light::LightTypes arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setIteratePerLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setIteratePerLight", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setIteratePerLight", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Light::LightTypes","setIteratePerLight", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Light::LightTypes >(val4);
  (arg1)->setIteratePerLight(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setIteratePerLight__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setIteratePerLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setIteratePerLight", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setIteratePerLight", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setIteratePerLight(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setIteratePerLight__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setIteratePerLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setIteratePerLight", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setIteratePerLight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setIteratePerLight(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Pass_setIteratePerLight__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pass_setIteratePerLight__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(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_Pass_setIteratePerLight__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Pass.setIteratePerLight", 
    "    void Pass.setIteratePerLight(bool enabled, bool onlyForOneLightType, Ogre::Light::LightTypes lightType)\n"
    "    void Pass.setIteratePerLight(bool enabled, bool onlyForOneLightType)\n"
    "    void Pass.setIteratePerLight(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getIteratePerLight(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getIteratePerLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getIteratePerLight();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getRunOnlyForOneLightType(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getRunOnlyForOneLightType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getRunOnlyForOneLightType();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getOnlyLightType(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Light::LightTypes 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getOnlyLightType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Light::LightTypes)((Ogre::Pass const *)arg1)->getOnlyLightType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setLightCountPerIteration(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setLightCountPerIteration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","setLightCountPerIteration", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setLightCountPerIteration(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getLightCountPerIteration(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getLightCountPerIteration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (unsigned short)((Ogre::Pass const *)arg1)->getLightCountPerIteration();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::Technique *)((Ogre::Pass const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setVertexProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setVertexProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setVertexProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setVertexProgram", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setVertexProgram((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setVertexProgram__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setVertexProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setVertexProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setVertexProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setVertexProgram(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_Ogre__Pass, 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_Pass_setVertexProgram__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pass_setVertexProgram__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.setVertexProgram", 
    "    void Pass.setVertexProgram(Ogre::String const &name, bool resetParams)\n"
    "    void Pass.setVertexProgram(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setVertexProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setVertexProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setVertexProgramParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setVertexProgramParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setVertexProgramParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getVertexProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getVertexProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getVertexProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getVertexProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getVertexProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getVertexProgramParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getVertexProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowCasterVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowCasterVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setShadowCasterVertexProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowCasterVertexProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowCasterVertexProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowCasterVertexProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowCasterVertexProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setShadowCasterVertexProgramParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setShadowCasterVertexProgramParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setShadowCasterVertexProgramParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowCasterVertexProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowCasterVertexProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowCasterVertexProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowCasterVertexProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowCasterVertexProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getShadowCasterVertexProgramParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowCasterVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowCasterVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowCasterVertexProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowCasterFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowCasterFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setShadowCasterFragmentProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowCasterFragmentProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowCasterFragmentProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowCasterFragmentProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowCasterFragmentProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setShadowCasterFragmentProgramParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setShadowCasterFragmentProgramParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setShadowCasterFragmentProgramParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowCasterFragmentProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowCasterFragmentProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowCasterFragmentProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowCasterFragmentProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowCasterFragmentProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getShadowCasterFragmentProgramParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowCasterFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowCasterFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowCasterFragmentProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowReceiverVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowReceiverVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setShadowReceiverVertexProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowReceiverVertexProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowReceiverVertexProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowReceiverVertexProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowReceiverVertexProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setShadowReceiverVertexProgramParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setShadowReceiverVertexProgramParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setShadowReceiverVertexProgramParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowReceiverFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowReceiverFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setShadowReceiverFragmentProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowReceiverFragmentProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowReceiverFragmentProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setShadowReceiverFragmentProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setShadowReceiverFragmentProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setShadowReceiverFragmentProgramParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setShadowReceiverFragmentProgramParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setShadowReceiverFragmentProgramParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowReceiverVertexProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowReceiverVertexProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowReceiverVertexProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowReceiverVertexProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowReceiverVertexProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getShadowReceiverVertexProgramParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowReceiverVertexProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowReceiverVertexProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowReceiverVertexProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowReceiverFragmentProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowReceiverFragmentProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getShadowReceiverFragmentProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowReceiverFragmentProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowReceiverFragmentProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getShadowReceiverFragmentProgramParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getShadowReceiverFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getShadowReceiverFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getShadowReceiverFragmentProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFragmentProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setFragmentProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFragmentProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setFragmentProgram", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setFragmentProgram((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFragmentProgram__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setFragmentProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFragmentProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setFragmentProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setFragmentProgram(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_Ogre__Pass, 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_Pass_setFragmentProgram__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pass_setFragmentProgram__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.setFragmentProgram", 
    "    void Pass.setFragmentProgram(Ogre::String const &name, bool resetParams)\n"
    "    void Pass.setFragmentProgram(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setFragmentProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setFragmentProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setFragmentProgramParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setFragmentProgramParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setFragmentProgramParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFragmentProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFragmentProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getFragmentProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFragmentProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFragmentProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getFragmentProgramParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getFragmentProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getFragmentProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getFragmentProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setGeometryProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setGeometryProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setGeometryProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setGeometryProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setGeometryProgram", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setGeometryProgram((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setGeometryProgram__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setGeometryProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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( "", "Ogre::String const &","setGeometryProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setGeometryProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setGeometryProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setGeometryProgram(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_Ogre__Pass, 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_Pass_setGeometryProgram__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pass_setGeometryProgram__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.setGeometryProgram", 
    "    void Pass.setGeometryProgram(Ogre::String const &name, bool resetParams)\n"
    "    void Pass.setGeometryProgram(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setGeometryProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setGeometryProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","setGeometryProgramParameters", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","setGeometryProgramParameters", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  (arg1)->setGeometryProgramParameters(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getGeometryProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getGeometryProgramName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::String *) &((Ogre::Pass const *)arg1)->getGeometryProgramName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getGeometryProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getGeometryProgramParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getGeometryProgramParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getGeometryProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgramPtr *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getGeometryProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::GpuProgramPtr *) &((Ogre::Pass const *)arg1)->getGeometryProgram();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__split(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Pass *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_split", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","_split", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Pass *)(arg1)->_split(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__notifyIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_notifyIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","_notifyIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->_notifyIndex(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__prepare(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->_prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->_unprepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__load(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->_load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__unload(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->_unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getHash(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getHash", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::uint32)((Ogre::Pass const *)arg1)->getHash();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__dirtyHash(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_dirtyHash", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->_dirtyHash();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__recalculateHash(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_recalculateHash", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->_recalculateHash();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__notifyNeedsRecompile(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","_notifyNeedsRecompile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->_notifyNeedsRecompile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__updateAutoParams(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::AutoParamDataSource *arg2 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","_updateAutoParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","_updateAutoParams", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","_updateAutoParams", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  ((Ogre::Pass const *)arg1)->_updateAutoParams((Ogre::AutoParamDataSource const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass__getTextureUnitWithContentTypeIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::TextureUnitState::ContentType arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","_getTextureUnitWithContentTypeIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureUnitState::ContentType","_getTextureUnitWithContentTypeIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureUnitState::ContentType >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","_getTextureUnitWithContentTypeIndex", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = (unsigned short)((Ogre::Pass const *)arg1)->_getTextureUnitWithContentTypeIndex(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setTextureFiltering(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::TextureFilterOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureFilterOptions","setTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureFilterOptions >(val2);
  (arg1)->setTextureFiltering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setTextureAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setTextureAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(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","setTextureAnisotropy", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setTextureAnisotropy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setNormaliseNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setNormaliseNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setNormaliseNormals", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setNormaliseNormals(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getNormaliseNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getNormaliseNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getNormaliseNormals();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getDirtyHashList(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass::PassSet *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Pass::PassSet *) &Ogre::Pass::getDirtyHashList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPassGraveyard(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass::PassSet *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Pass::PassSet *) &Ogre::Pass::getPassGraveyard();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_clearDirtyHashList(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::Pass::clearDirtyHashList();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_processPendingPassUpdates(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::Pass::processPendingPassUpdates();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_queueForDeletion(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","queueForDeletion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  (arg1)->queueForDeletion();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_isAmbientOnly(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","isAmbientOnly", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->isAmbientOnly();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setPassIterationCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setPassIterationCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setPassIterationCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setPassIterationCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getPassIterationCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getPassIterationCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = ((Ogre::Pass const *)arg1)->getPassIterationCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_applyTextureAliases__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","applyTextureAliases", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)((Ogre::Pass const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_applyTextureAliases__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::AliasTextureNamePairList *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  result = (bool)((Ogre::Pass const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_applyTextureAliases(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Pass_applyTextureAliases__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Pass_applyTextureAliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Pass.applyTextureAliases", 
    "    bool Pass.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Pass.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setLightScissoringEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setLightScissoringEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLightScissoringEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLightScissoringEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getLightScissoringEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getLightScissoringEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getLightScissoringEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setLightClipPlanesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setLightClipPlanesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLightClipPlanesEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLightClipPlanesEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getLightClipPlanesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getLightClipPlanesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (bool)((Ogre::Pass const *)arg1)->getLightClipPlanesEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setIlluminationStage(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  Ogre::IlluminationStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","setIlluminationStage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::IlluminationStage","setIlluminationStage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::IlluminationStage >(val2);
  (arg1)->setIlluminationStage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getIlluminationStage(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IlluminationStage 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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getIlluminationStage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::IlluminationStage)((Ogre::Pass const *)arg1)->getIlluminationStage();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setHashFunction__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass::BuiltinHashFunction arg1 ;
  int val1 ;
  int ecode1 = 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( "", "Ogre::Pass::BuiltinHashFunction","Ogre::Pass::setHashFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Pass::BuiltinHashFunction >(val1);
  Ogre::Pass::setHashFunction(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_setHashFunction__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass::HashFunc *arg1 = (Ogre::Pass::HashFunc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__Pass__HashFunc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass::HashFunc *","Ogre::Pass::setHashFunction", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass::HashFunc * >(argp1);
  Ogre::Pass::setHashFunction(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_setHashFunction(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass__HashFunc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pass_setHashFunction__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    {
      int res = SWIG_AsVal_int(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_Pass_setHashFunction__SWIG_0(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "Pass.setHashFunction", 
    "    void Pass.setHashFunction(Ogre::Pass::BuiltinHashFunction builtin)\n"
    "    void Pass.setHashFunction(Ogre::Pass::HashFunc *hashFunc)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getHashFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass::HashFunc *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Pass::HashFunc *)Ogre::Pass::getHashFunction();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass__HashFunc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getBuiltinHashFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass::BuiltinHashFunction arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Ogre::Pass::HashFunc *result = 0 ;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::Pass::BuiltinHashFunction","Ogre::Pass::getBuiltinHashFunction", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Pass::BuiltinHashFunction >(val1);
  result = (Ogre::Pass::HashFunc *)Ogre::Pass::getBuiltinHashFunction(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass__HashFunc, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getUserObjectBindings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Pass_getUserObjectBindings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Pass *arg1 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Pass const *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Pass * >(argp1);
  result = (Ogre::UserObjectBindings *) &((Ogre::Pass const *)arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Pass_getUserObjectBindings(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_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pass_getUserObjectBindings__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Pass_getUserObjectBindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Pass.getUserObjectBindings", 
    "    Ogre::UserObjectBindings const & Pass.getUserObjectBindings()\n"
    "    Ogre::UserObjectBindings const & Pass.getUserObjectBindings()\n");
  
  return Qnil;
}


swig_class SwigClassIlluminationPass;

SWIGINTERN VALUE
_wrap_IlluminationPass_stage_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 0 ;
  Ogre::IlluminationStage arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","stage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::IlluminationStage","stage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::IlluminationStage >(val2);
  if (arg1) (arg1)->stage = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IlluminationPass_stage_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IlluminationStage 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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","stage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  result = (Ogre::IlluminationStage) ((arg1)->stage);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IlluminationPass_pass_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","pass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","pass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  if (arg1) (arg1)->pass = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IlluminationPass_pass_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pass *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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","pass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  result = (Ogre::Pass *) ((arg1)->pass);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IlluminationPass_destroyOnShutdown_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","destroyOnShutdown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","destroyOnShutdown", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->destroyOnShutdown = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IlluminationPass_destroyOnShutdown_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","destroyOnShutdown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  result = (bool) ((arg1)->destroyOnShutdown);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IlluminationPass_originalPass_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","originalPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","originalPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  if (arg1) (arg1)->originalPass = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IlluminationPass_originalPass_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IlluminationPass *arg1 = (Ogre::IlluminationPass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pass *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_Ogre__IlluminationPass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IlluminationPass *","originalPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IlluminationPass * >(argp1);
  result = (Ogre::Pass *) ((arg1)->originalPass);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_IlluminationPass(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::IlluminationPass";
  Ogre::IlluminationPass *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::IlluminationPass *)new Ogre::IlluminationPass();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_IlluminationPass(Ogre::IlluminationPass *arg1) {
    delete arg1;
}

swig_class SwigClassPixelCountLodStrategy;

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

SWIGINTERN VALUE
_wrap_new_PixelCountLodStrategy(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PixelCountLodStrategy";
  Ogre::PixelCountLodStrategy *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PixelCountLodStrategy *)new Ogre::PixelCountLodStrategy();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_getBaseValue(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *arg1 = (Ogre::PixelCountLodStrategy *) 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_Ogre__PixelCountLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelCountLodStrategy const *","getBaseValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelCountLodStrategy * >(argp1);
  result = (Ogre::Real)((Ogre::PixelCountLodStrategy const *)arg1)->getBaseValue();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_transformBias(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *arg1 = (Ogre::PixelCountLodStrategy *) 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_Ogre__PixelCountLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelCountLodStrategy const *","transformBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelCountLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","transformBias", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (Ogre::Real)((Ogre::PixelCountLodStrategy const *)arg1)->transformBias(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_getIndex__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *arg1 = (Ogre::PixelCountLodStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Mesh::MeshLodUsageList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::ushort 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_Ogre__PixelCountLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelCountLodStrategy const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelCountLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Mesh::MeshLodUsageList const &","getIndex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::MeshLodUsageList const &","getIndex", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Mesh::MeshLodUsageList * >(argp3);
  result = (Ogre::ushort)((Ogre::PixelCountLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Mesh::MeshLodUsageList const &)*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_getIndex__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *arg1 = (Ogre::PixelCountLodStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Material::LodValueList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::ushort 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_Ogre__PixelCountLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelCountLodStrategy const *","getIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelCountLodStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Material::LodValueList const &","getIndex", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Material::LodValueList const &","getIndex", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Material::LodValueList * >(argp3);
  result = (Ogre::ushort)((Ogre::PixelCountLodStrategy const *)arg1)->getIndex(arg2,(Ogre::Material::LodValueList const &)*arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PixelCountLodStrategy_getIndex(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PixelCountLodStrategy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PixelCountLodStrategy_getIndex__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PixelCountLodStrategy, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PixelCountLodStrategy_getIndex__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PixelCountLodStrategy.getIndex", 
    "    Ogre::ushort PixelCountLodStrategy.getIndex(Ogre::Real value, Ogre::Mesh::MeshLodUsageList const &meshLodUsageList)\n"
    "    Ogre::ushort PixelCountLodStrategy.getIndex(Ogre::Real value, Ogre::Material::LodValueList const &materialLodValueList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_sort(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *arg1 = (Ogre::PixelCountLodStrategy *) 0 ;
  Ogre::Mesh::MeshLodUsageList *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_Ogre__PixelCountLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelCountLodStrategy const *","sort", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelCountLodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::MeshLodUsageList &","sort", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::MeshLodUsageList &","sort", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::MeshLodUsageList * >(argp2);
  ((Ogre::PixelCountLodStrategy const *)arg1)->sort(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_isSorted(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *arg1 = (Ogre::PixelCountLodStrategy *) 0 ;
  Ogre::Mesh::LodValueList *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_Ogre__PixelCountLodStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PixelCountLodStrategy const *","isSorted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PixelCountLodStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh::LodValueList const &","isSorted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Mesh::LodValueList const &","isSorted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh::LodValueList * >(argp2);
  result = (bool)((Ogre::PixelCountLodStrategy const *)arg1)->isSorted((Ogre::Mesh::LodValueList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PixelCountLodStrategy *) &Ogre::PixelCountLodStrategy::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelCountLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PixelCountLodStrategy_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::PixelCountLodStrategy *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PixelCountLodStrategy *)Ogre::PixelCountLodStrategy::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelCountLodStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PixelCountLodStrategy(Ogre::PixelCountLodStrategy *arg1) {
    delete arg1;
}

swig_class SwigClassPlatformInformation;

SWIGINTERN VALUE
_wrap_PlatformInformation_getCpuIdentifier(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::PlatformInformation::getCpuIdentifier();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlatformInformation_getCpuFeatures(int argc, VALUE *argv, VALUE self) {
  Ogre::uint result;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::uint)Ogre::PlatformInformation::getCpuFeatures();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlatformInformation_hasCpuFeature(int argc, VALUE *argv, VALUE self) {
  Ogre::PlatformInformation::CpuFeatures arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  bool result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::PlatformInformation::CpuFeatures","Ogre::PlatformInformation::hasCpuFeature", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PlatformInformation::CpuFeatures >(val1);
  result = (bool)Ogre::PlatformInformation::hasCpuFeature(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlatformInformation_log(int argc, VALUE *argv, VALUE self) {
  Ogre::Log *arg1 = (Ogre::Log *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__Log, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Log *","Ogre::PlatformInformation::log", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Log * >(argp1);
  Ogre::PlatformInformation::log(arg1);
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PlatformInformation(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PlatformInformation";
  Ogre::PlatformInformation *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PlatformInformation *)new Ogre::PlatformInformation();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PlatformInformation(Ogre::PlatformInformation *arg1) {
    delete arg1;
}

swig_class SwigClassPlugin;

SWIGINTERN void
free_Ogre_Plugin(Ogre::Plugin *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Plugin_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Plugin *arg1 = (Ogre::Plugin *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plugin const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plugin * >(argp1);
  result = (Ogre::String *) &((Ogre::Plugin const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plugin_install(int argc, VALUE *argv, VALUE self) {
  Ogre::Plugin *arg1 = (Ogre::Plugin *) 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_Ogre__Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plugin *","install", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plugin * >(argp1);
  (arg1)->install();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plugin_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::Plugin *arg1 = (Ogre::Plugin *) 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_Ogre__Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plugin *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plugin * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plugin_shutdown(int argc, VALUE *argv, VALUE self) {
  Ogre::Plugin *arg1 = (Ogre::Plugin *) 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_Ogre__Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plugin *","shutdown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plugin * >(argp1);
  (arg1)->shutdown();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Plugin_uninstall(int argc, VALUE *argv, VALUE self) {
  Ogre::Plugin *arg1 = (Ogre::Plugin *) 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_Ogre__Plugin, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Plugin *","uninstall", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Plugin * >(argp1);
  (arg1)->uninstall();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPrefabFactory;

SWIGINTERN VALUE
_wrap_PrefabFactory_createPrefab(int argc, VALUE *argv, VALUE self) {
  Ogre::Mesh *arg1 = (Ogre::Mesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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(argv[0], &argp1,SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Mesh *","Ogre::PrefabFactory::createPrefab", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Mesh * >(argp1);
  result = (bool)Ogre::PrefabFactory::createPrefab(arg1);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_PrefabFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PrefabFactory";
  Ogre::PrefabFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PrefabFactory *)new Ogre::PrefabFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PrefabFactory(Ogre::PrefabFactory *arg1) {
    delete arg1;
}

swig_class SwigClassProfile;

SWIGINTERN VALUE
_wrap_new_Profile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::uint32 arg2 ;
  int res1 = SWIG_OLDOBJ ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Profile";
  Ogre::Profile *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::Profile", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Profile", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","Ogre::Profile", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  result = (Ogre::Profile *)new Ogre::Profile((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Profile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Profile";
  Ogre::Profile *result = 0 ;
  
  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 &","Ogre::Profile", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Profile", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Profile *)new Ogre::Profile((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Profile(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;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Profile__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _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_Profile__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Profile.new", 
    "    Profile.new(Ogre::String const &profileName, Ogre::uint32 groupID)\n"
    "    Profile.new(Ogre::String const &profileName)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Profile(Ogre::Profile *arg1) {
    delete arg1;
}

swig_class SwigClassProfiler;

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

SWIGINTERN VALUE
_wrap_new_Profiler(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Profiler";
  Ogre::Profiler *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Profiler *)new Ogre::Profiler();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Profiler(Ogre::Profiler *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Profiler_setTimer(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::Timer *arg2 = (Ogre::Timer *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","setTimer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Timer, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Timer *","setTimer", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Timer * >(argp2);
  (arg1)->setTimer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getTimer(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Timer *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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","getTimer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::Timer *)(arg1)->getTimer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Timer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_beginProfile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::uint32 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","beginProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","beginProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","beginProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","beginProfile", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  (arg1)->beginProfile((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_beginProfile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","beginProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","beginProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","beginProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->beginProfile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Profiler_beginProfile(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_Ogre__Profiler, 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_Profiler_beginProfile__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Profiler, 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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Profiler_beginProfile__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Profiler.beginProfile", 
    "    void Profiler.beginProfile(Ogre::String const &profileName, Ogre::uint32 groupID)\n"
    "    void Profiler.beginProfile(Ogre::String const &profileName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_endProfile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::uint32 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","endProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","endProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","endProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint32","endProfile", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint32 >(val3);
  (arg1)->endProfile((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_endProfile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","endProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","endProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","endProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->endProfile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Profiler_endProfile(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_Ogre__Profiler, 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_Profiler_endProfile__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Profiler, 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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Profiler_endProfile__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Profiler.endProfile", 
    "    void Profiler.endProfile(Ogre::String const &profileName, Ogre::uint32 groupID)\n"
    "    void Profiler.endProfile(Ogre::String const &profileName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_setEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","setEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (bool)((Ogre::Profiler const *)arg1)->getEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_enableProfile(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","enableProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","enableProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","enableProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->enableProfile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_disableProfile(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","disableProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","disableProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","disableProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->disableProfile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_setProfileGroupMask(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::uint32 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","setProfileGroupMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setProfileGroupMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setProfileGroupMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getProfileGroupMask(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getProfileGroupMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::uint32)((Ogre::Profiler const *)arg1)->getProfileGroupMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_watchForMax(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","watchForMax", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","watchForMax", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","watchForMax", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->watchForMax((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_watchForMin(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","watchForMin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","watchForMin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","watchForMin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->watchForMin((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_watchForLimit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","watchForLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","watchForLimit", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","watchForLimit", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","watchForLimit", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","watchForLimit", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (bool)(arg1)->watchForLimit((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_watchForLimit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","watchForLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(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( "", "Ogre::String const &","watchForLimit", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","watchForLimit", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","watchForLimit", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)(arg1)->watchForLimit((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Profiler_watchForLimit(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_Ogre__Profiler, 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_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Profiler_watchForLimit__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Profiler, 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_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Profiler_watchForLimit__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Profiler.watchForLimit", 
    "    bool Profiler.watchForLimit(Ogre::String const &profileName, Ogre::Real limit, bool greaterThan)\n"
    "    bool Profiler.watchForLimit(Ogre::String const &profileName, Ogre::Real limit)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_logResults(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","logResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  (arg1)->logResults();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_setDisplayMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::Profiler::DisplayMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","setDisplayMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Profiler::DisplayMode","setDisplayMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Profiler::DisplayMode >(val2);
  (arg1)->setDisplayMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getDisplayMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Profiler::DisplayMode 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getDisplayMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::Profiler::DisplayMode)((Ogre::Profiler const *)arg1)->getDisplayMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_setUpdateDisplayFrequency(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::uint 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","setUpdateDisplayFrequency", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint","setUpdateDisplayFrequency", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint >(val2);
  (arg1)->setUpdateDisplayFrequency(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getUpdateDisplayFrequency(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getUpdateDisplayFrequency", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::uint)((Ogre::Profiler const *)arg1)->getUpdateDisplayFrequency();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_setOverlayDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","setOverlayDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOverlayDimensions", 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","setOverlayDimensions", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setOverlayDimensions(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_setOverlayPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler *","setOverlayPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOverlayPosition", 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","setOverlayPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setOverlayPosition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getOverlayWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getOverlayWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayWidth();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getOverlayHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getOverlayHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getOverlayLeft(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getOverlayLeft", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayLeft();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getOverlayTop(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *arg1 = (Ogre::Profiler *) 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_Ogre__Profiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Profiler const *","getOverlayTop", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Profiler * >(argp1);
  result = (Ogre::Real)((Ogre::Profiler const *)arg1)->getOverlayTop();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Profiler *) &Ogre::Profiler::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Profiler, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Profiler_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::Profiler *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Profiler *)Ogre::Profiler::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Profiler, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRenderObjectListener;

SWIGINTERN void
free_Ogre_RenderObjectListener(Ogre::RenderObjectListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderObjectListener_notifyRenderSingleObject(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderObjectListener *arg1 = (Ogre::RenderObjectListener *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::AutoParamDataSource *arg4 = (Ogre::AutoParamDataSource *) 0 ;
  Ogre::LightList *arg5 = (Ogre::LightList *) 0 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Swig::Director *director = 0;
  bool upcall = false;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderObjectListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderObjectListener *","notifyRenderSingleObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderObjectListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","notifyRenderSingleObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass const *","notifyRenderSingleObject", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__AutoParamDataSource, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::AutoParamDataSource const *","notifyRenderSingleObject", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::AutoParamDataSource * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::LightList const *","notifyRenderSingleObject", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::LightList * >(argp5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","notifyRenderSingleObject", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  director = dynamic_cast<Swig::Director *>(arg1);
  upcall = (director && (director->swig_get_self() == self));
  try {
    if (upcall) {
      Swig::DirectorPureVirtualException::raise("Ogre::RenderObjectListener::notifyRenderSingleObject");
    } else {
      (arg1)->notifyRenderSingleObject(arg2,(Ogre::Pass const *)arg3,(Ogre::AutoParamDataSource const *)arg4,(Ogre::LightList const *)arg5,arg6);
    }
  } catch (Swig::DirectorException& e) {
    rb_exc_raise(e.getError());
    SWIG_fail;
  }
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderObjectListener(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderObjectListener";
  Ogre::RenderObjectListener *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  arg1 = self;
  if ( strcmp(rb_obj_classname(self), classname) != 0 ) {
    /* subclassed */
    result = (Ogre::RenderObjectListener *)new SwigDirector_RenderObjectListener(arg1); 
  } else {
    rb_raise(rb_eNameError,"accessing abstract class or protected constructor"); 
    return Qnil;
  }
  
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_disown_RenderObjectListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderObjectListener *arg1 = (Ogre::RenderObjectListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__RenderObjectListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderObjectListener *","disown_RenderObjectListener", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderObjectListener * >(argp1);
  {
    Swig::Director *director = SWIG_DIRECTOR_CAST(arg1);
    if (director) director->swig_disown();
  }
  
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassTechnique;

SWIGINTERN VALUE
_wrap_new_Technique__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Technique";
  Ogre::Technique *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__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","Ogre::Technique", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  result = (Ogre::Technique *)new Ogre::Technique(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Technique__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Material *arg1 = (Ogre::Material *) 0 ;
  Ogre::Technique *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Technique";
  Ogre::Technique *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__Material, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Material *","Ogre::Technique", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Material * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__Technique,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Technique const &","Ogre::Technique", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Technique const &","Ogre::Technique", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Technique * >(argp2);
  result = (Ogre::Technique *)new Ogre::Technique(arg1,(Ogre::Technique const &)*arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Technique(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__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_Technique__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Material, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_new_Technique__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Technique.new", 
    "    Technique.new(Ogre::Material *parent)\n"
    "    Technique.new(Ogre::Material *parent, Ogre::Technique const &oth)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_Technique(Ogre::Technique *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Technique_isSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","isSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->isSupported();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__compile(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","_compile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_compile", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->_compile(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_checkGPURules(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::StringUtil::StrStreamType *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","checkGPURules", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringUtil::StrStreamType &","checkGPURules", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StringUtil::StrStreamType &","checkGPURules", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StringUtil::StrStreamType * >(argp2);
  result = (bool)(arg1)->checkGPURules(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_checkHardwareSupport(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  Ogre::StringUtil::StrStreamType *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","checkHardwareSupport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","checkHardwareSupport", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::StringUtil::StrStreamType &","checkHardwareSupport", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StringUtil::StrStreamType &","checkHardwareSupport", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::StringUtil::StrStreamType * >(argp3);
  result = (bool)(arg1)->checkHardwareSupport(arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__compileIlluminationPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","_compileIlluminationPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  (arg1)->_compileIlluminationPasses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_createPass(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pass *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","createPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (Ogre::Pass *)(arg1)->createPass();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getPass__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::Pass *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","getPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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","getPass", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::Pass *)(arg1)->getPass(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getPass__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Pass *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","getPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","getPass", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getPass", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Pass *)(arg1)->getPass((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_getPass(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Technique_getPass__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_Technique_getPass__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Technique.getPass", 
    "    Ogre::Pass * Technique.getPass(unsigned short index)\n"
    "    Ogre::Pass * Technique.getPass(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getNumPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getNumPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (unsigned short)((Ogre::Technique const *)arg1)->getNumPasses();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_removePass(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","removePass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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","removePass", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removePass(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_removeAllPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","removeAllPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  (arg1)->removeAllPasses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_movePass(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","movePass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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","movePass", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","movePass", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = (bool)(arg1)->movePass(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getPassIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::Pass *,Ogre::STLAllocator< Ogre::Pass *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","getPassIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (arg1)->getPassIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Technique::PassIterator(static_cast< const Ogre::Technique::PassIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getIlluminationPassIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::IlluminationPass *,Ogre::STLAllocator< Ogre::IlluminationPass *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","getIlluminationPassIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (arg1)->getIlluminationPassIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Technique::IlluminationPassIterator(static_cast< const Ogre::Technique::IlluminationPassIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Material *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (Ogre::Material *)((Ogre::Technique const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Material, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (Ogre::String *) &((Ogre::Technique const *)arg1)->getResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_isTransparent(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","isTransparent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->isTransparent();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_isTransparentSortingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","isTransparentSortingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->isTransparentSortingEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_isTransparentSortingForced(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","isTransparentSortingForced", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->isTransparentSortingForced();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__prepare(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","_prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  (arg1)->_prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","_unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  (arg1)->_unprepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__load(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","_load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  (arg1)->_load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__unload(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","_unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  (arg1)->_unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__notifyNeedsRecompile(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","_notifyNeedsRecompile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  (arg1)->_notifyNeedsRecompile();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getShadowCasterMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getShadowCasterMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = ((Ogre::Technique const *)arg1)->getShadowCasterMaterial();
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setShadowCasterMaterial__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::MaterialPtr arg2 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setShadowCasterMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr","setShadowCasterMaterial", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr","setShadowCasterMaterial", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::MaterialPtr * >(argp2));
    }
  }
  (arg1)->setShadowCasterMaterial(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setShadowCasterMaterial__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setShadowCasterMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","setShadowCasterMaterial", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowCasterMaterial", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowCasterMaterial((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setShadowCasterMaterial(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_setShadowCasterMaterial__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_Technique_setShadowCasterMaterial__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Technique.setShadowCasterMaterial", 
    "    void Technique.setShadowCasterMaterial(Ogre::MaterialPtr val)\n"
    "    void Technique.setShadowCasterMaterial(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getShadowReceiverMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getShadowReceiverMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = ((Ogre::Technique const *)arg1)->getShadowReceiverMaterial();
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setShadowReceiverMaterial__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::MaterialPtr arg2 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setShadowReceiverMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr","setShadowReceiverMaterial", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr","setShadowReceiverMaterial", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::MaterialPtr * >(argp2));
    }
  }
  (arg1)->setShadowReceiverMaterial(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setShadowReceiverMaterial__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setShadowReceiverMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","setShadowReceiverMaterial", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowReceiverMaterial", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowReceiverMaterial((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setShadowReceiverMaterial(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MaterialPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_setShadowReceiverMaterial__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_Technique_setShadowReceiverMaterial__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Technique.setShadowReceiverMaterial", 
    "    void Technique.setShadowReceiverMaterial(Ogre::MaterialPtr val)\n"
    "    void Technique.setShadowReceiverMaterial(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setPointSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setPointSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setPointSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setPointSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setAmbient__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setAmbient", 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","setAmbient", 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","setAmbient", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setAmbient(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setAmbient__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::ColourValue *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setAmbient", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setAmbient", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setAmbient((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setAmbient(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_setAmbient__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_Technique_setAmbient__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Technique.setAmbient", 
    "    void Technique.setAmbient(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Technique.setAmbient(Ogre::ColourValue const &ambient)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setDiffuse__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDiffuse", 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","setDiffuse", 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","setDiffuse", 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","setDiffuse", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setDiffuse(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setDiffuse__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::ColourValue *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setDiffuse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setDiffuse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setDiffuse((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setDiffuse(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_setDiffuse__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Technique_setDiffuse__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Technique.setDiffuse", 
    "    void Technique.setDiffuse(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Technique.setDiffuse(Ogre::ColourValue const &diffuse)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSpecular__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSpecular", 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","setSpecular", 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","setSpecular", 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","setSpecular", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setSpecular(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSpecular__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::ColourValue *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSpecular", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSpecular", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setSpecular((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setSpecular(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_setSpecular__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Technique_setSpecular__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Technique.setSpecular", 
    "    void Technique.setSpecular(Ogre::Real red, Ogre::Real green, Ogre::Real blue, Ogre::Real alpha)\n"
    "    void Technique.setSpecular(Ogre::ColourValue const &specular)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setShininess(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setShininess", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShininess", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShininess(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSelfIllumination__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSelfIllumination", 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","setSelfIllumination", 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","setSelfIllumination", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setSelfIllumination(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSelfIllumination__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::ColourValue *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSelfIllumination", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setSelfIllumination", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setSelfIllumination((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setSelfIllumination(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_setSelfIllumination__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_Technique_setSelfIllumination__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Technique.setSelfIllumination", 
    "    void Technique.setSelfIllumination(Ogre::Real red, Ogre::Real green, Ogre::Real blue)\n"
    "    void Technique.setSelfIllumination(Ogre::ColourValue const &selfIllum)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setDepthCheckEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setDepthCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthCheckEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDepthCheckEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setDepthWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setDepthWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDepthWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDepthWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setDepthFunction(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::CompareFunction arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setDepthFunction", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CompareFunction","setDepthFunction", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CompareFunction >(val2);
  (arg1)->setDepthFunction(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setColourWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setColourWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setColourWriteEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setColourWriteEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::CullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::CullingMode","setCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::CullingMode >(val2);
  (arg1)->setCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setManualCullingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::ManualCullingMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setManualCullingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ManualCullingMode","setManualCullingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ManualCullingMode >(val2);
  (arg1)->setManualCullingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setLightingEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setLightingEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLightingEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLightingEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setShadingMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::ShadeOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setShadingMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadeOptions","setShadingMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadeOptions >(val2);
  (arg1)->setShadingMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setFog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::Real arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  float val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_float(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::Real >(val7);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setFog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setFog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setFog__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  Ogre::ColourValue *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::ColourValue * >(argp4);
  (arg1)->setFog(arg2,arg3,(Ogre::ColourValue const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setFog__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  Ogre::FogMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::FogMode >(val3);
  (arg1)->setFog(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setFog__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFog(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setFog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Technique_setFog__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_Technique_setFog__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Technique_setFog__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Technique_setFog__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_Technique_setFog__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_float(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_Technique_setFog__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "Technique.setFog", 
    "    void Technique.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void Technique.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void Technique.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void Technique.setFog(bool overrideScene, Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void Technique.setFog(bool overrideScene, Ogre::FogMode mode)\n"
    "    void Technique.setFog(bool overrideScene)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setDepthBias(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  float arg2 ;
  float arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setDepthBias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setDepthBias", 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","setDepthBias", 3, argv[1] ));
  } 
  arg3 = static_cast< float >(val3);
  (arg1)->setDepthBias(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setTextureFiltering(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::TextureFilterOptions arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setTextureFiltering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TextureFilterOptions","setTextureFiltering", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TextureFilterOptions >(val2);
  (arg1)->setTextureFiltering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setTextureAnisotropy(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setTextureAnisotropy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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","setTextureAnisotropy", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setTextureAnisotropy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::SceneBlendType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  (arg1)->setSceneBlending(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSeparateSceneBlending__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::SceneBlendType arg2 ;
  Ogre::SceneBlendType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendType >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendType","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendType >(val3);
  (arg1)->setSeparateSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  (arg1)->setSceneBlending(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setSceneBlending(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Technique_setSceneBlending__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _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_Technique_setSceneBlending__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Technique.setSceneBlending", 
    "    void Technique.setSceneBlending(Ogre::SceneBlendType const sbt)\n"
    "    void Technique.setSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSeparateSceneBlending__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::SceneBlendFactor arg2 ;
  Ogre::SceneBlendFactor arg3 ;
  Ogre::SceneBlendFactor arg4 ;
  Ogre::SceneBlendFactor arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSeparateSceneBlending", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneBlendFactor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneBlendFactor >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SceneBlendFactor >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::SceneBlendFactor","setSeparateSceneBlending", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::SceneBlendFactor >(val5);
  (arg1)->setSeparateSceneBlending(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_setSeparateSceneBlending(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_Ogre__Technique, 0);
    _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_Technique_setSeparateSceneBlending__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _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) {
          {
            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_Technique_setSeparateSceneBlending__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Technique.setSeparateSceneBlending", 
    "    void Technique.setSeparateSceneBlending(Ogre::SceneBlendType const sbt, Ogre::SceneBlendType const sbta)\n"
    "    void Technique.setSeparateSceneBlending(Ogre::SceneBlendFactor const sourceFactor, Ogre::SceneBlendFactor const destFactor, Ogre::SceneBlendFactor const sourceFactorAlpha, Ogre::SceneBlendFactor const destFactorAlpha)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setLodIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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","setLodIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setLodIndex(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getLodIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getLodIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (unsigned short)((Ogre::Technique const *)arg1)->getLodIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setSchemeName(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setSchemeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","setSchemeName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSchemeName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSchemeName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getSchemeName(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getSchemeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (Ogre::String *) &((Ogre::Technique const *)arg1)->getSchemeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique__getSchemeIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","_getSchemeIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (unsigned short)((Ogre::Technique const *)arg1)->_getSchemeIndex();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_isDepthWriteEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","isDepthWriteEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->isDepthWriteEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_isDepthCheckEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","isDepthCheckEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->isDepthCheckEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_hasColourWriteDisabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","hasColourWriteDisabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (bool)((Ogre::Technique const *)arg1)->hasColourWriteDisabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_setName(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","setName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","setName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (Ogre::String *) &((Ogre::Technique const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_applyTextureAliases__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::AliasTextureNamePairList *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","applyTextureAliases", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (bool)((Ogre::Technique const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_applyTextureAliases__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::AliasTextureNamePairList *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","applyTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, 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,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AliasTextureNamePairList const &","applyTextureAliases", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AliasTextureNamePairList * >(argp2);
  result = (bool)((Ogre::Technique const *)arg1)->applyTextureAliases((Ogre::AliasTextureNamePairList const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_applyTextureAliases(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_applyTextureAliases__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, 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, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Technique_applyTextureAliases__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Technique.applyTextureAliases", 
    "    bool Technique.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList, bool const apply)\n"
    "    bool Technique.applyTextureAliases(Ogre::AliasTextureNamePairList const &aliasList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_addGPUVendorRule__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::GPUVendor arg2 ;
  Ogre::Technique::IncludeOrExclude arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","addGPUVendorRule", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GPUVendor","addGPUVendorRule", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GPUVendor >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Technique::IncludeOrExclude","addGPUVendorRule", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Technique::IncludeOrExclude >(val3);
  (arg1)->addGPUVendorRule(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_addGPUVendorRule__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  GPUVendorRule *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","addGPUVendorRule", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPUVendorRule,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPUVendorRule const &","addGPUVendorRule", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPUVendorRule const &","addGPUVendorRule", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPUVendorRule * >(argp2);
  (arg1)->addGPUVendorRule((GPUVendorRule const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_addGPUVendorRule(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPUVendorRule, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_addGPUVendorRule__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _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_Technique_addGPUVendorRule__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Technique.addGPUVendorRule", 
    "    void Technique.addGPUVendorRule(Ogre::GPUVendor vendor, Ogre::Technique::IncludeOrExclude includeOrExclude)\n"
    "    void Technique.addGPUVendorRule(GPUVendorRule const &rule)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_removeGPUVendorRule(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::GPUVendor arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","removeGPUVendorRule", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::GPUVendor","removeGPUVendorRule", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::GPUVendor >(val2);
  (arg1)->removeGPUVendorRule(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getGPUVendorRuleIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< GPUVendorRule,Ogre::STLAllocator< GPUVendorRule,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getGPUVendorRuleIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = ((Ogre::Technique const *)arg1)->getGPUVendorRuleIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Technique::GPUVendorRuleIterator(static_cast< const Ogre::Technique::GPUVendorRuleIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_addGPUDeviceNameRule__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Technique::IncludeOrExclude arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","addGPUDeviceNameRule", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","addGPUDeviceNameRule", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addGPUDeviceNameRule", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Technique::IncludeOrExclude","addGPUDeviceNameRule", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Technique::IncludeOrExclude >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","addGPUDeviceNameRule", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->addGPUDeviceNameRule((Ogre::String const &)*arg2,arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_addGPUDeviceNameRule__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Technique::IncludeOrExclude arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","addGPUDeviceNameRule", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","addGPUDeviceNameRule", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addGPUDeviceNameRule", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Technique::IncludeOrExclude","addGPUDeviceNameRule", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Technique::IncludeOrExclude >(val3);
  (arg1)->addGPUDeviceNameRule((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_addGPUDeviceNameRule__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  GPUDeviceNameRule *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","addGPUDeviceNameRule", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_GPUDeviceNameRule,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "GPUDeviceNameRule const &","addGPUDeviceNameRule", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "GPUDeviceNameRule const &","addGPUDeviceNameRule", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< GPUDeviceNameRule * >(argp2);
  (arg1)->addGPUDeviceNameRule((GPUDeviceNameRule const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_addGPUDeviceNameRule(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_GPUDeviceNameRule, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Technique_addGPUDeviceNameRule__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Technique_addGPUDeviceNameRule__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Technique_addGPUDeviceNameRule__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Technique.addGPUDeviceNameRule", 
    "    void Technique.addGPUDeviceNameRule(Ogre::String const &devicePattern, Ogre::Technique::IncludeOrExclude includeOrExclude, bool caseSensitive)\n"
    "    void Technique.addGPUDeviceNameRule(Ogre::String const &devicePattern, Ogre::Technique::IncludeOrExclude includeOrExclude)\n"
    "    void Technique.addGPUDeviceNameRule(GPUDeviceNameRule const &rule)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_removeGPUDeviceNameRule(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  Ogre::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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","removeGPUDeviceNameRule", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(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( "", "Ogre::String const &","removeGPUDeviceNameRule", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeGPUDeviceNameRule", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeGPUDeviceNameRule((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getGPUDeviceNameRuleIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< GPUDeviceNameRule,Ogre::STLAllocator< GPUDeviceNameRule,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getGPUDeviceNameRuleIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = ((Ogre::Technique const *)arg1)->getGPUDeviceNameRuleIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Technique::GPUDeviceNameRuleIterator(static_cast< const Ogre::Technique::GPUDeviceNameRuleIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getUserObjectBindings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (Ogre::UserObjectBindings *) &(arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Technique_getUserObjectBindings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Technique *arg1 = (Ogre::Technique *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::UserObjectBindings *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_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Technique const *","getUserObjectBindings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Technique * >(argp1);
  result = (Ogre::UserObjectBindings *) &((Ogre::Technique const *)arg1)->getUserObjectBindings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__UserObjectBindings, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Technique_getUserObjectBindings(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_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Technique_getUserObjectBindings__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Technique, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Technique_getUserObjectBindings__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "Technique.getUserObjectBindings", 
    "    Ogre::UserObjectBindings const & Technique.getUserObjectBindings()\n"
    "    Ogre::UserObjectBindings const & Technique.getUserObjectBindings()\n");
  
  return Qnil;
}


swig_class SwigClassRenderablePass;

SWIGINTERN VALUE
_wrap_RenderablePass_renderable_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderablePass *arg1 = (Ogre::RenderablePass *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 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_Ogre__RenderablePass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderablePass *","renderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderablePass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","renderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  if (arg1) (arg1)->renderable = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderablePass_renderable_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderablePass *arg1 = (Ogre::RenderablePass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Renderable *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_Ogre__RenderablePass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderablePass *","renderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderablePass * >(argp1);
  result = (Ogre::Renderable *) ((arg1)->renderable);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderablePass_pass_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderablePass *arg1 = (Ogre::RenderablePass *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 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_Ogre__RenderablePass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderablePass *","pass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderablePass * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","pass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  if (arg1) (arg1)->pass = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderablePass_pass_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderablePass *arg1 = (Ogre::RenderablePass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Pass *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_Ogre__RenderablePass, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderablePass *","pass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderablePass * >(argp1);
  result = (Ogre::Pass *) ((arg1)->pass);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderablePass(int argc, VALUE *argv, VALUE self) {
  Ogre::Renderable *arg1 = (Ogre::Renderable *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderablePass";
  Ogre::RenderablePass *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__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Renderable *","Ogre::RenderablePass", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Renderable * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","Ogre::RenderablePass", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  result = (Ogre::RenderablePass *)new Ogre::RenderablePass(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderablePass(Ogre::RenderablePass *arg1) {
    delete arg1;
}

swig_class SwigClassQueuedRenderableVisitor;

SWIGINTERN void
free_Ogre_QueuedRenderableVisitor(Ogre::QueuedRenderableVisitor *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_QueuedRenderableVisitor_visit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableVisitor *arg1 = (Ogre::QueuedRenderableVisitor *) 0 ;
  Ogre::RenderablePass *arg2 = (Ogre::RenderablePass *) 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_Ogre__QueuedRenderableVisitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableVisitor *","visit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableVisitor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderablePass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderablePass *","visit", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderablePass * >(argp2);
  (arg1)->visit(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableVisitor_visit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableVisitor *arg1 = (Ogre::QueuedRenderableVisitor *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__QueuedRenderableVisitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableVisitor *","visit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableVisitor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass const *","visit", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  result = (bool)(arg1)->visit((Ogre::Pass const *)arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableVisitor_visit__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableVisitor *arg1 = (Ogre::QueuedRenderableVisitor *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 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_Ogre__QueuedRenderableVisitor, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableVisitor *","visit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableVisitor * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","visit", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  (arg1)->visit(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_QueuedRenderableVisitor_visit(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_Ogre__QueuedRenderableVisitor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderablePass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_QueuedRenderableVisitor_visit__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__QueuedRenderableVisitor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_QueuedRenderableVisitor_visit__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__QueuedRenderableVisitor, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_QueuedRenderableVisitor_visit__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "QueuedRenderableVisitor.visit", 
    "    void QueuedRenderableVisitor.visit(Ogre::RenderablePass *rp)\n"
    "    void QueuedRenderableVisitor.visit(Ogre::Pass const *p)\n"
    "    void QueuedRenderableVisitor.visit(Ogre::Renderable *r)\n");
  
  return Qnil;
}


swig_class SwigClassQueuedRenderableCollection;

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

SWIGINTERN VALUE
_wrap_new_QueuedRenderableCollection(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::QueuedRenderableCollection";
  Ogre::QueuedRenderableCollection *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::QueuedRenderableCollection *)new Ogre::QueuedRenderableCollection();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_QueuedRenderableCollection(Ogre::QueuedRenderableCollection *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::QueuedRenderableCollection.clear

  call-seq:
    clear

Clear QueuedRenderableCollection contents.
*/
SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_removePassGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection *","removePassGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","removePassGroup", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  (arg1)->removePassGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_resetOrganisationModes(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection *","resetOrganisationModes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  (arg1)->resetOrganisationModes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_addOrganisationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 0 ;
  Ogre::QueuedRenderableCollection::OrganisationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection *","addOrganisationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection::OrganisationMode","addOrganisationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::QueuedRenderableCollection::OrganisationMode >(val2);
  (arg1)->addOrganisationMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_addRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  Ogre::Renderable *arg3 = (Ogre::Renderable *) 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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection *","addRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","addRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Renderable *","addRenderable", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Renderable * >(argp3);
  (arg1)->addRenderable(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_sort(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection *","sort", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","sort", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->sort((Ogre::Camera const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_acceptVisitor(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 0 ;
  Ogre::QueuedRenderableVisitor *arg2 = (Ogre::QueuedRenderableVisitor *) 0 ;
  Ogre::QueuedRenderableCollection::OrganisationMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection const *","acceptVisitor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__QueuedRenderableVisitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableVisitor *","acceptVisitor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::QueuedRenderableVisitor * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection::OrganisationMode","acceptVisitor", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::QueuedRenderableCollection::OrganisationMode >(val3);
  ((Ogre::QueuedRenderableCollection const *)arg1)->acceptVisitor(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_QueuedRenderableCollection_merge(int argc, VALUE *argv, VALUE self) {
  Ogre::QueuedRenderableCollection *arg1 = (Ogre::QueuedRenderableCollection *) 0 ;
  Ogre::QueuedRenderableCollection *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_Ogre__QueuedRenderableCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__QueuedRenderableCollection,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection const &","merge", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::QueuedRenderableCollection const &","merge", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::QueuedRenderableCollection * >(argp2);
  (arg1)->merge((Ogre::QueuedRenderableCollection const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderPriorityGroup;

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

SWIGINTERN VALUE
_wrap_new_RenderPriorityGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderPriorityGroup";
  Ogre::RenderPriorityGroup *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","Ogre::RenderPriorityGroup", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::RenderPriorityGroup", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::RenderPriorityGroup", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::RenderPriorityGroup", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::RenderPriorityGroup *)new Ogre::RenderPriorityGroup(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderPriorityGroup(Ogre::RenderPriorityGroup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderPriorityGroup_getSolidsBasic(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::QueuedRenderableCollection *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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup const *","getSolidsBasic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsBasic();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_getSolidsDiffuseSpecular(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::QueuedRenderableCollection *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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup const *","getSolidsDiffuseSpecular", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsDiffuseSpecular();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_getSolidsDecal(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::QueuedRenderableCollection *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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup const *","getSolidsDecal", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsDecal();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_getSolidsNoShadowReceive(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::QueuedRenderableCollection *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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup const *","getSolidsNoShadowReceive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getSolidsNoShadowReceive();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_getTransparentsUnsorted(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::QueuedRenderableCollection *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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup const *","getTransparentsUnsorted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getTransparentsUnsorted();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_getTransparents(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::QueuedRenderableCollection *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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup const *","getTransparents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  result = (Ogre::QueuedRenderableCollection *) &((Ogre::RenderPriorityGroup const *)arg1)->getTransparents();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__QueuedRenderableCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_resetOrganisationModes(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","resetOrganisationModes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  (arg1)->resetOrganisationModes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_addOrganisationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  Ogre::QueuedRenderableCollection::OrganisationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","addOrganisationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection::OrganisationMode","addOrganisationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::QueuedRenderableCollection::OrganisationMode >(val2);
  (arg1)->addOrganisationMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_defaultOrganisationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","defaultOrganisationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  (arg1)->defaultOrganisationMode();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_addRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Technique *arg3 = (Ogre::Technique *) 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","addRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","addRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Technique *","addRenderable", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Technique * >(argp3);
  (arg1)->addRenderable(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_sort(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","sort", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","sort", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->sort((Ogre::Camera const *)arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderPriorityGroup.clear

  call-seq:
    clear

Clear RenderPriorityGroup contents.
*/
SWIGINTERN VALUE
_wrap_RenderPriorityGroup_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_setSplitPassesByLightingType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","setSplitPassesByLightingType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitPassesByLightingType", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitPassesByLightingType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_setSplitNoShadowPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","setSplitNoShadowPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitNoShadowPasses", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitNoShadowPasses(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_setShadowCastersCannotBeReceivers(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","setShadowCastersCannotBeReceivers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowCastersCannotBeReceivers", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowCastersCannotBeReceivers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderPriorityGroup_merge(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderPriorityGroup *arg1 = (Ogre::RenderPriorityGroup *) 0 ;
  Ogre::RenderPriorityGroup *arg2 = (Ogre::RenderPriorityGroup *) 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_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderPriorityGroup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderPriorityGroup const *","merge", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderPriorityGroup * >(argp2);
  (arg1)->merge((Ogre::RenderPriorityGroup const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderQueueGroup;

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

SWIGINTERN VALUE
_wrap_new_RenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueue *arg1 = (Ogre::RenderQueue *) 0 ;
  bool arg2 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderQueueGroup";
  Ogre::RenderQueueGroup *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","Ogre::RenderQueueGroup", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::RenderQueueGroup", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::RenderQueueGroup", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::RenderQueueGroup", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::RenderQueueGroup *)new Ogre::RenderQueueGroup(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderQueueGroup(Ogre::RenderQueueGroup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderQueueGroup_getIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::RenderQueueGroup::PriorityMapIterator > 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","getIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  result = (arg1)->getIterator();
  vresult = SWIG_NewPointerObj((new Ogre::RenderQueueGroup::PriorityMapIterator(static_cast< const Ogre::RenderQueueGroup::PriorityMapIterator& >(result))), SWIGTYPE_p_Ogre__RenderQueueGroup__PriorityMapIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_getIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::RenderQueueGroup::ConstPriorityMapIterator > 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup const *","getIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  result = ((Ogre::RenderQueueGroup const *)arg1)->getIterator();
  vresult = SWIG_NewPointerObj((new Ogre::RenderQueueGroup::ConstPriorityMapIterator(static_cast< const Ogre::RenderQueueGroup::ConstPriorityMapIterator& >(result))), SWIGTYPE_p_Ogre__RenderQueueGroup__ConstPriorityMapIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderQueueGroup_getIterator(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_Ogre__RenderQueueGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderQueueGroup_getIterator__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderQueueGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderQueueGroup_getIterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RenderQueueGroup.getIterator", 
    "    Ogre::RenderQueueGroup::ConstPriorityMapIterator RenderQueueGroup.getIterator()\n"
    "    Ogre::RenderQueueGroup::ConstPriorityMapIterator RenderQueueGroup.getIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_addRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Technique *arg3 = (Ogre::Technique *) 0 ;
  Ogre::ushort arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","addRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","addRenderable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Technique *","addRenderable", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Technique * >(argp3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::ushort","addRenderable", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::ushort >(val4);
  (arg1)->addRenderable(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueGroup.clear

  call-seq:
    clear(destroy=false)
    clear

Clear RenderQueueGroup contents.
*/
SWIGINTERN VALUE
_wrap_RenderQueueGroup_clear__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","clear", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->clear(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_clear__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderQueueGroup_clear(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_Ogre__RenderQueueGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RenderQueueGroup_clear__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderQueueGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RenderQueueGroup_clear__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RenderQueueGroup.clear", 
    "    void RenderQueueGroup.clear(bool destroy)\n"
    "    void RenderQueueGroup.clear()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_setShadowsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","setShadowsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowsEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowsEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_getShadowsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup const *","getShadowsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  result = (bool)((Ogre::RenderQueueGroup const *)arg1)->getShadowsEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_setSplitPassesByLightingType(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","setSplitPassesByLightingType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitPassesByLightingType", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitPassesByLightingType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_setSplitNoShadowPasses(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","setSplitNoShadowPasses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitNoShadowPasses", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitNoShadowPasses(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_setShadowCastersCannotBeReceivers(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","setShadowCastersCannotBeReceivers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowCastersCannotBeReceivers", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowCastersCannotBeReceivers(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_resetOrganisationModes(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","resetOrganisationModes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  (arg1)->resetOrganisationModes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_addOrganisationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  Ogre::QueuedRenderableCollection::OrganisationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","addOrganisationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection::OrganisationMode","addOrganisationMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::QueuedRenderableCollection::OrganisationMode >(val2);
  (arg1)->addOrganisationMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_defaultOrganisationMode(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","defaultOrganisationMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  (arg1)->defaultOrganisationMode();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueGroup_merge(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueGroup *arg1 = (Ogre::RenderQueueGroup *) 0 ;
  Ogre::RenderQueueGroup *arg2 = (Ogre::RenderQueueGroup *) 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_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup const *","merge", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp2);
  (arg1)->merge((Ogre::RenderQueueGroup const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderQueueInvocation;

SWIGINTERN VALUE
_wrap_new_RenderQueueInvocation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::uint8 arg1 ;
  Ogre::String *arg2 = 0 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::RenderQueueInvocation";
  Ogre::RenderQueueInvocation *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::RenderQueueInvocation", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint8 >(val1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::RenderQueueInvocation", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RenderQueueInvocation", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderQueueInvocation *)new Ogre::RenderQueueInvocation(arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RenderQueueInvocation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::uint8 arg1 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RenderQueueInvocation";
  Ogre::RenderQueueInvocation *result = 0 ;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::RenderQueueInvocation", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint8 >(val1);
  result = (Ogre::RenderQueueInvocation *)new Ogre::RenderQueueInvocation(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RenderQueueInvocation(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;
    {
      int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
      _v = SWIG_CheckState(res);
    }
    if (_v) {
      return _wrap_new_RenderQueueInvocation__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_char(argv[0], NULL);
      _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_new_RenderQueueInvocation__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "RenderQueueInvocation.new", 
    "    RenderQueueInvocation.new(Ogre::uint8 renderQueueGroupID, Ogre::String const &invocationName)\n"
    "    RenderQueueInvocation.new(Ogre::uint8 renderQueueGroupID)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderQueueInvocation(Ogre::RenderQueueInvocation *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderQueueInvocation_getRenderQueueGroupID(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation const *","getRenderQueueGroupID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  result = (Ogre::uint8)((Ogre::RenderQueueInvocation const *)arg1)->getRenderQueueGroupID();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_getInvocationName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation const *","getInvocationName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  result = (Ogre::String *) &((Ogre::RenderQueueInvocation const *)arg1)->getInvocationName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_setSolidsOrganisation(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 0 ;
  Ogre::QueuedRenderableCollection::OrganisationMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation *","setSolidsOrganisation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection::OrganisationMode","setSolidsOrganisation", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::QueuedRenderableCollection::OrganisationMode >(val2);
  (arg1)->setSolidsOrganisation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_getSolidsOrganisation(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::QueuedRenderableCollection::OrganisationMode 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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation const *","getSolidsOrganisation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  result = (Ogre::QueuedRenderableCollection::OrganisationMode)((Ogre::RenderQueueInvocation const *)arg1)->getSolidsOrganisation();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_setSuppressShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation *","setSuppressShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSuppressShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSuppressShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_getSuppressShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation const *","getSuppressShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  result = (bool)((Ogre::RenderQueueInvocation const *)arg1)->getSuppressShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_setSuppressRenderStateChanges(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation *","setSuppressRenderStateChanges", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSuppressRenderStateChanges", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSuppressRenderStateChanges(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_getSuppressRenderStateChanges(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation const *","getSuppressRenderStateChanges", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  result = (bool)((Ogre::RenderQueueInvocation const *)arg1)->getSuppressRenderStateChanges();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_invoke(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocation *arg1 = (Ogre::RenderQueueInvocation *) 0 ;
  Ogre::RenderQueueGroup *arg2 = (Ogre::RenderQueueGroup *) 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 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_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation *","invoke", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","invoke", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","invoke", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  (arg1)->invoke(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::RenderQueueInvocation::RENDER_QUEUE_INVOCATION_SHADOWS));
  return _val;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::RenderQueueInvocation::RENDER_QUEUE_INVOCATION_SHADOWS""' of type '""Ogre::String""'"); 
    }
    Ogre::RenderQueueInvocation::RENDER_QUEUE_INVOCATION_SHADOWS = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


swig_class SwigClassRenderQueueInvocationSequence;

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

SWIGINTERN VALUE
_wrap_new_RenderQueueInvocationSequence(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::RenderQueueInvocationSequence";
  Ogre::RenderQueueInvocationSequence *result = 0 ;
  
  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 &","Ogre::RenderQueueInvocationSequence", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RenderQueueInvocationSequence", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::RenderQueueInvocationSequence *)new Ogre::RenderQueueInvocationSequence((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderQueueInvocationSequence(Ogre::RenderQueueInvocationSequence *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  result = (Ogre::String *) &((Ogre::RenderQueueInvocationSequence const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_add__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::RenderQueueInvocation *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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence *","add", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","add", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  {
    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 &","add", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","add", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::RenderQueueInvocation *)(arg1)->add(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocation, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_add__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 0 ;
  Ogre::RenderQueueInvocation *arg2 = (Ogre::RenderQueueInvocation *) 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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence *","add", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueueInvocation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocation *","add", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueueInvocation * >(argp2);
  (arg1)->add(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderQueueInvocationSequence_add(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_Ogre__RenderQueueInvocationSequence, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderQueueInvocation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RenderQueueInvocationSequence_add__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _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_RenderQueueInvocationSequence_add__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RenderQueueInvocationSequence.add", 
    "    void RenderQueueInvocationSequence.add(Ogre::uint8 renderQueueGroupID, Ogre::String const &invocationName)\n"
    "    void RenderQueueInvocationSequence.add(Ogre::RenderQueueInvocation *i)\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocationSequence.size

  call-seq:
    size -> size_t

Size or Length of the RenderQueueInvocationSequence.
*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_size(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence const *","size", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  result = ((Ogre::RenderQueueInvocationSequence const *)arg1)->size();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocationSequence.clear

  call-seq:
    clear

Clear RenderQueueInvocationSequence contents.
*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::RenderQueueInvocation *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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence *","get", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","get", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::RenderQueueInvocation *)(arg1)->get(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocation, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_remove(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence *","remove", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","remove", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->remove(arg2);
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderQueueInvocationSequence.iterator

  call-seq:
    iterator -> RenderQueueInvocationIterator

Return an iterator to the RenderQueueInvocationSequence.
*/
SWIGINTERN VALUE
_wrap_RenderQueueInvocationSequence_iterator(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderQueueInvocationSequence *arg1 = (Ogre::RenderQueueInvocationSequence *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::VectorIterator< Ogre::vector< Ogre::RenderQueueInvocation *,Ogre::STLAllocator< Ogre::RenderQueueInvocation *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderQueueInvocationSequence *","iterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderQueueInvocationSequence * >(argp1);
  result = (arg1)->iterator();
  vresult = SWIG_NewPointerObj((new Ogre::RenderQueueInvocationIterator(static_cast< const Ogre::RenderQueueInvocationIterator& >(result))), SWIGTYPE_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRenderSystemCapabilitiesManager;

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

SWIGINTERN VALUE
_wrap_new_RenderSystemCapabilitiesManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderSystemCapabilitiesManager";
  Ogre::RenderSystemCapabilitiesManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderSystemCapabilitiesManager *)new Ogre::RenderSystemCapabilitiesManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderSystemCapabilitiesManager(Ogre::RenderSystemCapabilitiesManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_parseCapabilitiesFromArchive__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesManager *arg1 = (Ogre::RenderSystemCapabilitiesManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesManager *","parseCapabilitiesFromArchive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesManager * >(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( "", "Ogre::String const &","parseCapabilitiesFromArchive", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseCapabilitiesFromArchive", 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 &","parseCapabilitiesFromArchive", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseCapabilitiesFromArchive", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","parseCapabilitiesFromArchive", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->parseCapabilitiesFromArchive((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_parseCapabilitiesFromArchive__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesManager *arg1 = (Ogre::RenderSystemCapabilitiesManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesManager *","parseCapabilitiesFromArchive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesManager * >(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( "", "Ogre::String const &","parseCapabilitiesFromArchive", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseCapabilitiesFromArchive", 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 &","parseCapabilitiesFromArchive", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","parseCapabilitiesFromArchive", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->parseCapabilitiesFromArchive((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_RenderSystemCapabilitiesManager_parseCapabilitiesFromArchive(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_Ogre__RenderSystemCapabilitiesManager, 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_RenderSystemCapabilitiesManager_parseCapabilitiesFromArchive__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RenderSystemCapabilitiesManager, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_RenderSystemCapabilitiesManager_parseCapabilitiesFromArchive__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RenderSystemCapabilitiesManager.parseCapabilitiesFromArchive", 
    "    void RenderSystemCapabilitiesManager.parseCapabilitiesFromArchive(Ogre::String const &filename, Ogre::String const &archiveType, bool recursive)\n"
    "    void RenderSystemCapabilitiesManager.parseCapabilitiesFromArchive(Ogre::String const &filename, Ogre::String const &archiveType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_loadParsedCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesManager *arg1 = (Ogre::RenderSystemCapabilitiesManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderSystemCapabilities *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_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesManager *","loadParsedCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesManager * >(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( "", "Ogre::String const &","loadParsedCapabilities", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadParsedCapabilities", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderSystemCapabilities *)(arg1)->loadParsedCapabilities((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_getCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesManager *arg1 = (Ogre::RenderSystemCapabilitiesManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::map< Ogre::String,Ogre::RenderSystemCapabilities *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::RenderSystemCapabilities * >,Ogre::GeneralAllocPolicy > >::type *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_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesManager const *","getCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesManager * >(argp1);
  result = (Ogre::map< Ogre::String,Ogre::RenderSystemCapabilities *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::RenderSystemCapabilities * >,Ogre::GeneralAllocPolicy > >::type *) &((Ogre::RenderSystemCapabilitiesManager const *)arg1)->getCapabilities();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager__addRenderSystemCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesManager *arg1 = (Ogre::RenderSystemCapabilitiesManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::RenderSystemCapabilities *arg3 = (Ogre::RenderSystemCapabilities *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesManager *","_addRenderSystemCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesManager * >(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( "", "Ogre::String const &","_addRenderSystemCapabilities", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_addRenderSystemCapabilities", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","_addRenderSystemCapabilities", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp3);
  (arg1)->_addRenderSystemCapabilities((Ogre::String const &)*arg2,arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderSystemCapabilitiesManager *) &Ogre::RenderSystemCapabilitiesManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderSystemCapabilitiesManager *)Ogre::RenderSystemCapabilitiesManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystemCapabilitiesManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRenderSystemCapabilitiesSerializer;

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

SWIGINTERN VALUE
_wrap_new_RenderSystemCapabilitiesSerializer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RenderSystemCapabilitiesSerializer";
  Ogre::RenderSystemCapabilitiesSerializer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RenderSystemCapabilitiesSerializer *)new Ogre::RenderSystemCapabilitiesSerializer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderSystemCapabilitiesSerializer(Ogre::RenderSystemCapabilitiesSerializer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesSerializer_writeScript(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesSerializer *arg1 = (Ogre::RenderSystemCapabilitiesSerializer *) 0 ;
  Ogre::RenderSystemCapabilities *arg2 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::String arg3 ;
  Ogre::String arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  
  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_Ogre__RenderSystemCapabilitiesSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesSerializer *","writeScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","writeScript", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "Ogre::String","writeScript", 3, argv[1] )); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "Ogre::String","writeScript", 4, argv[2] )); 
    }
    arg4 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  (arg1)->writeScript((Ogre::RenderSystemCapabilities const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesSerializer_writeString(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesSerializer *arg1 = (Ogre::RenderSystemCapabilitiesSerializer *) 0 ;
  Ogre::RenderSystemCapabilities *arg2 = (Ogre::RenderSystemCapabilities *) 0 ;
  Ogre::String arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::String 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_Ogre__RenderSystemCapabilitiesSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesSerializer *","writeString", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities const *","writeString", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp2);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "Ogre::String","writeString", 3, argv[1] )); 
    }
    arg3 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  result = (arg1)->writeString((Ogre::RenderSystemCapabilities const *)arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderSystemCapabilitiesSerializer_parseScript(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderSystemCapabilitiesSerializer *arg1 = (Ogre::RenderSystemCapabilitiesSerializer *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__RenderSystemCapabilitiesSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilitiesSerializer *","parseScript", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderSystemCapabilitiesSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","parseScript", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","parseScript", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->parseScript(*arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRenderWindow;

SWIGINTERN VALUE
_wrap_RenderWindow_create(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bool arg5 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","create", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(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","create", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","create", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","create", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  (arg1)->create((Ogre::String const &)*arg2,arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_setFullscreen(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  bool arg2 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","setFullscreen", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFullscreen", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(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","setFullscreen", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(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","setFullscreen", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  (arg1)->setFullscreen(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_destroy(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  (arg1)->destroy();
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RenderWindow.resize

  call-seq:
    resize(width, height)

Resize the size of the RenderWindow.
*/
SWIGINTERN VALUE
_wrap_RenderWindow_resize(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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 ;
  
  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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","resize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(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","resize", 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","resize", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  (arg1)->resize(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_windowMovedOrResized(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","windowMovedOrResized", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  (arg1)->windowMovedOrResized();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_reposition(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  int arg2 ;
  int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","reposition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","reposition", 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","reposition", 3, argv[1] ));
  } 
  arg3 = static_cast< int >(val3);
  (arg1)->reposition(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_setVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isHidden(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isHidden", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isHidden();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_setHidden(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","setHidden", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setHidden", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setHidden(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_setVSyncEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","setVSyncEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVSyncEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVSyncEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isVSyncEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isVSyncEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isVSyncEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_setVSyncInterval(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","setVSyncInterval", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(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","setVSyncInterval", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setVSyncInterval(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_getVSyncInterval(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","getVSyncInterval", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (unsigned int)((Ogre::RenderWindow const *)arg1)->getVSyncInterval();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isActive(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isActive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isActive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isClosed(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isClosed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isPrimary(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isPrimary", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isPrimary();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isFullScreen(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isFullScreen", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isFullScreen();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_getMetrics(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  unsigned int *arg2 = 0 ;
  unsigned int *arg3 = 0 ;
  unsigned int *arg4 = 0 ;
  int *arg5 = 0 ;
  int *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","getMetrics", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "unsigned int &","getMetrics", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned int &","getMetrics", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< unsigned int * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "unsigned int &","getMetrics", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned int &","getMetrics", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< unsigned int * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_unsigned_int,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "unsigned int &","getMetrics", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "unsigned int &","getMetrics", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< unsigned int * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "int &","getMetrics", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getMetrics", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< int * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_int,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "int &","getMetrics", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "int &","getMetrics", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< int * >(argp6);
  (arg1)->getMetrics(*arg2,*arg3,*arg4,*arg5,*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_suggestPixelFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","suggestPixelFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (Ogre::PixelFormat)((Ogre::RenderWindow const *)arg1)->suggestPixelFormat();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_isDeactivatedOnFocusChange(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow const *","isDeactivatedOnFocusChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  result = (bool)((Ogre::RenderWindow const *)arg1)->isDeactivatedOnFocusChange();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RenderWindow_setDeactivateOnFocusChange(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","setDeactivateOnFocusChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDeactivateOnFocusChange", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDeactivateOnFocusChange(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RenderWindow(Ogre::RenderWindow *arg1) {
    delete arg1;
}

swig_class SwigClassWorkQueue;

SWIGINTERN void
free_Ogre_WorkQueue(Ogre::WorkQueue *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_WorkQueue_startup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","startup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","startup", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->startup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_startup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","startup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  (arg1)->startup();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_WorkQueue_startup(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_Ogre__WorkQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_WorkQueue_startup__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__WorkQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_WorkQueue_startup__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "WorkQueue.startup", 
    "    void WorkQueue.startup(bool forceRestart)\n"
    "    void WorkQueue.startup()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_addRequestHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::RequestHandler *arg3 = (Ogre::WorkQueue::RequestHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","addRequestHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequestHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__RequestHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::RequestHandler *","addRequestHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::RequestHandler * >(argp3);
  (arg1)->addRequestHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_removeRequestHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::RequestHandler *arg3 = (Ogre::WorkQueue::RequestHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","removeRequestHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","removeRequestHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__RequestHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::RequestHandler *","removeRequestHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::RequestHandler * >(argp3);
  (arg1)->removeRequestHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_addResponseHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::ResponseHandler *arg3 = (Ogre::WorkQueue::ResponseHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","addResponseHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addResponseHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__ResponseHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::ResponseHandler *","addResponseHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::ResponseHandler * >(argp3);
  (arg1)->addResponseHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_removeResponseHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::ResponseHandler *arg3 = (Ogre::WorkQueue::ResponseHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","removeResponseHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","removeResponseHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__ResponseHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::ResponseHandler *","removeResponseHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::ResponseHandler * >(argp3);
  (arg1)->removeResponseHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_addRequest__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::Any *arg4 = 0 ;
  Ogre::uint8 arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::WorkQueue::RequestID result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","addRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Any const &","addRequest", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","addRequest", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Any * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint8","addRequest", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint8 >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","addRequest", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5,arg6);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_addRequest__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::Any *arg4 = 0 ;
  Ogre::uint8 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  Ogre::WorkQueue::RequestID result;
  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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","addRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Any const &","addRequest", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","addRequest", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Any * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint8","addRequest", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint8 >(val5);
  result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_addRequest__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::Any *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::WorkQueue::RequestID 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","addRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Any const &","addRequest", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","addRequest", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Any * >(argp4);
  result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_WorkQueue_addRequest(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__WorkQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Any, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_WorkQueue_addRequest__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__WorkQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Any, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_WorkQueue_addRequest__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__WorkQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Any, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_WorkQueue_addRequest__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "WorkQueue.addRequest", 
    "    Ogre::WorkQueue::RequestID WorkQueue.addRequest(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount, bool forceSynchronous)\n"
    "    Ogre::WorkQueue::RequestID WorkQueue.addRequest(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount)\n"
    "    Ogre::WorkQueue::RequestID WorkQueue.addRequest(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_abortRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::WorkQueue::RequestID arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","abortRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::RequestID","abortRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::WorkQueue::RequestID >(val2);
  (arg1)->abortRequest(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_abortRequestsByChannel(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","abortRequestsByChannel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","abortRequestsByChannel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->abortRequestsByChannel(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_abortAllRequests(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","abortAllRequests", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  (arg1)->abortAllRequests();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_setPaused(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","setPaused", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPaused", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPaused(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_isPaused(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","isPaused", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  result = (bool)((Ogre::WorkQueue const *)arg1)->isPaused();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_setRequestsAccepted(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","setRequestsAccepted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setRequestsAccepted", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setRequestsAccepted(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_getRequestsAccepted(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","getRequestsAccepted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  result = (bool)((Ogre::WorkQueue const *)arg1)->getRequestsAccepted();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_processResponses(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","processResponses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  (arg1)->processResponses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_getResponseProcessingTimeLimit(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","getResponseProcessingTimeLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  result = (unsigned long)((Ogre::WorkQueue const *)arg1)->getResponseProcessingTimeLimit();
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_setResponseProcessingTimeLimit(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","setResponseProcessingTimeLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","setResponseProcessingTimeLimit", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned long >(val2);
  (arg1)->setResponseProcessingTimeLimit(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_shutdown(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","shutdown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(argp1);
  (arg1)->shutdown();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WorkQueue_getChannel(int argc, VALUE *argv, VALUE self) {
  Ogre::WorkQueue *arg1 = (Ogre::WorkQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::uint16 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_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","getChannel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WorkQueue * >(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( "", "Ogre::String const &","getChannel", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getChannel", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::uint16)(arg1)->getChannel((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassDefaultWorkQueueBase;

SWIGINTERN void
free_Ogre_DefaultWorkQueueBase(Ogre::DefaultWorkQueueBase *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  result = (Ogre::String *) &((Ogre::DefaultWorkQueueBase const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_getWorkerThreadCount(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase const *","getWorkerThreadCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  result = ((Ogre::DefaultWorkQueueBase const *)arg1)->getWorkerThreadCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_setWorkerThreadCount(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","setWorkerThreadCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setWorkerThreadCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setWorkerThreadCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_getWorkersCanAccessRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase const *","getWorkersCanAccessRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->getWorkersCanAccessRenderSystem();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_setWorkersCanAccessRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","setWorkersCanAccessRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setWorkersCanAccessRenderSystem", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setWorkersCanAccessRenderSystem(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase__processNextRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","_processNextRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  (arg1)->_processNextRequest();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase__threadMain(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","_threadMain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  (arg1)->_threadMain();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_isShuttingDown(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase const *","isShuttingDown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->isShuttingDown();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_addRequestHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::RequestHandler *arg3 = (Ogre::WorkQueue::RequestHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","addRequestHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequestHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__RequestHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::RequestHandler *","addRequestHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::RequestHandler * >(argp3);
  (arg1)->addRequestHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_removeRequestHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::RequestHandler *arg3 = (Ogre::WorkQueue::RequestHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","removeRequestHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","removeRequestHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__RequestHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::RequestHandler *","removeRequestHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::RequestHandler * >(argp3);
  (arg1)->removeRequestHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_addResponseHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::ResponseHandler *arg3 = (Ogre::WorkQueue::ResponseHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","addResponseHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addResponseHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__ResponseHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::ResponseHandler *","addResponseHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::ResponseHandler * >(argp3);
  (arg1)->addResponseHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_removeResponseHandler(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::WorkQueue::ResponseHandler *arg3 = (Ogre::WorkQueue::ResponseHandler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","removeResponseHandler", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","removeResponseHandler", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue__ResponseHandler, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue::ResponseHandler *","removeResponseHandler", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue::ResponseHandler * >(argp3);
  (arg1)->removeResponseHandler(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_addRequest__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::Any *arg4 = 0 ;
  Ogre::uint8 arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  Ogre::WorkQueue::RequestID result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","addRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Any const &","addRequest", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","addRequest", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Any * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint8","addRequest", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint8 >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","addRequest", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5,arg6);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_addRequest__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::Any *arg4 = 0 ;
  Ogre::uint8 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  Ogre::WorkQueue::RequestID result;
  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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","addRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Any const &","addRequest", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","addRequest", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Any * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint8","addRequest", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint8 >(val5);
  result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4,arg5);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_addRequest__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::Any *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::WorkQueue::RequestID 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","addRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","addRequest", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Any,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Any const &","addRequest", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Any const &","addRequest", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Any * >(argp4);
  result = (Ogre::WorkQueue::RequestID)(arg1)->addRequest(arg2,arg3,(Ogre::Any const &)*arg4);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_DefaultWorkQueueBase_addRequest(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultWorkQueueBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Any, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_DefaultWorkQueueBase_addRequest__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultWorkQueueBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Any, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_DefaultWorkQueueBase_addRequest__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__DefaultWorkQueueBase, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Any, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_DefaultWorkQueueBase_addRequest__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "DefaultWorkQueueBase.addRequest", 
    "    Ogre::WorkQueue::RequestID DefaultWorkQueueBase.addRequest(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount, bool forceSynchronous)\n"
    "    Ogre::WorkQueue::RequestID DefaultWorkQueueBase.addRequest(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData, Ogre::uint8 retryCount)\n"
    "    Ogre::WorkQueue::RequestID DefaultWorkQueueBase.addRequest(Ogre::uint16 channel, Ogre::uint16 requestType, Ogre::Any const &rData)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_abortRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::WorkQueue::RequestID arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","abortRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::RequestID","abortRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::WorkQueue::RequestID >(val2);
  (arg1)->abortRequest(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_abortRequestsByChannel(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","abortRequestsByChannel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","abortRequestsByChannel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->abortRequestsByChannel(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_abortAllRequests(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","abortAllRequests", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  (arg1)->abortAllRequests();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_setPaused(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","setPaused", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPaused", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPaused(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_isPaused(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase const *","isPaused", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->isPaused();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_setRequestsAccepted(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","setRequestsAccepted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setRequestsAccepted", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setRequestsAccepted(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_getRequestsAccepted(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase const *","getRequestsAccepted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  result = (bool)((Ogre::DefaultWorkQueueBase const *)arg1)->getRequestsAccepted();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_processResponses(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","processResponses", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  (arg1)->processResponses();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_getResponseProcessingTimeLimit(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase const *","getResponseProcessingTimeLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  result = (unsigned long)((Ogre::DefaultWorkQueueBase const *)arg1)->getResponseProcessingTimeLimit();
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultWorkQueueBase_setResponseProcessingTimeLimit(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultWorkQueueBase *arg1 = (Ogre::DefaultWorkQueueBase *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__DefaultWorkQueueBase, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultWorkQueueBase *","setResponseProcessingTimeLimit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultWorkQueueBase * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","setResponseProcessingTimeLimit", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned long >(val2);
  (arg1)->setResponseProcessingTimeLimit(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassBackgroundProcessResult;

SWIGINTERN VALUE
_wrap_BackgroundProcessResult_error_set(int argc, VALUE *argv, VALUE self) {
  Ogre::BackgroundProcessResult *arg1 = (Ogre::BackgroundProcessResult *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__BackgroundProcessResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BackgroundProcessResult *","error", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BackgroundProcessResult * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","error", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->error = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BackgroundProcessResult_error_get(int argc, VALUE *argv, VALUE self) {
  Ogre::BackgroundProcessResult *arg1 = (Ogre::BackgroundProcessResult *) 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_Ogre__BackgroundProcessResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BackgroundProcessResult *","error", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BackgroundProcessResult * >(argp1);
  result = (bool) ((arg1)->error);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BackgroundProcessResult_message_set(int argc, VALUE *argv, VALUE self) {
  Ogre::BackgroundProcessResult *arg1 = (Ogre::BackgroundProcessResult *) 0 ;
  Ogre::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_Ogre__BackgroundProcessResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BackgroundProcessResult *","message", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BackgroundProcessResult * >(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( "", "Ogre::String const &","message", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","message", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->message = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BackgroundProcessResult_message_get(int argc, VALUE *argv, VALUE self) {
  Ogre::BackgroundProcessResult *arg1 = (Ogre::BackgroundProcessResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__BackgroundProcessResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BackgroundProcessResult *","message", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BackgroundProcessResult * >(argp1);
  result = (Ogre::String *) & ((arg1)->message);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_BackgroundProcessResult(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::BackgroundProcessResult";
  Ogre::BackgroundProcessResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::BackgroundProcessResult *)new Ogre::BackgroundProcessResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BackgroundProcessResult(Ogre::BackgroundProcessResult *arg1) {
    delete arg1;
}

swig_class SwigClassResourceBackgroundQueue;

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

SWIGINTERN VALUE
_wrap_new_ResourceBackgroundQueue(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ResourceBackgroundQueue";
  Ogre::ResourceBackgroundQueue *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ResourceBackgroundQueue *)new Ogre::ResourceBackgroundQueue();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ResourceBackgroundQueue(Ogre::ResourceBackgroundQueue *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialise(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  (arg1)->initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_shutdown(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","shutdown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  (arg1)->shutdown();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialiseResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg3 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","initialiseResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","initialiseResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","initialiseResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","initialiseResourceGroup", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp3);
  result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseResourceGroup((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialiseResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","initialiseResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","initialiseResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","initialiseResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseResourceGroup((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_initialiseResourceGroup(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_Ogre__ResourceBackgroundQueue, 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_ResourceBackgroundQueue_initialiseResourceGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ResourceBackgroundQueue_initialiseResourceGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.initialiseResourceGroup", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialiseResourceGroup(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialiseResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialiseAllResourceGroups__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg2 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","initialiseAllResourceGroups", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","initialiseAllResourceGroups", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp2);
  result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseAllResourceGroups(arg2);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_initialiseAllResourceGroups__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","initialiseAllResourceGroups", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  result = (Ogre::BackgroundProcessTicket)(arg1)->initialiseAllResourceGroups();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_initialiseAllResourceGroups(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_Ogre__ResourceBackgroundQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ResourceBackgroundQueue_initialiseAllResourceGroups__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_ResourceBackgroundQueue_initialiseAllResourceGroups__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ResourceBackgroundQueue.initialiseAllResourceGroups", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialiseAllResourceGroups(Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.initialiseAllResourceGroups()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepareResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg3 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","prepareResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","prepareResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepareResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","prepareResourceGroup", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp3);
  result = (Ogre::BackgroundProcessTicket)(arg1)->prepareResourceGroup((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepareResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","prepareResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","prepareResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepareResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BackgroundProcessTicket)(arg1)->prepareResourceGroup((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_prepareResourceGroup(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_Ogre__ResourceBackgroundQueue, 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_ResourceBackgroundQueue_prepareResourceGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ResourceBackgroundQueue_prepareResourceGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.prepareResourceGroup", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepareResourceGroup(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepareResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_loadResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg3 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","loadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","loadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","loadResourceGroup", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp3);
  result = (Ogre::BackgroundProcessTicket)(arg1)->loadResourceGroup((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_loadResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","loadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","loadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BackgroundProcessTicket)(arg1)->loadResourceGroup((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_loadResourceGroup(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_Ogre__ResourceBackgroundQueue, 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_ResourceBackgroundQueue_loadResourceGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ResourceBackgroundQueue_loadResourceGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.loadResourceGroup", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.loadResourceGroup(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.loadResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_unload__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg4 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","unload", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 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 &","unload", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","unload", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp4);
  result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  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_ResourceBackgroundQueue_unload__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","unload", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 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 &","unload", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  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_ResourceBackgroundQueue_unload__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::ResourceBackgroundQueue::Listener *arg4 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","unload", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","unload", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","unload", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp4);
  result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_unload__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","unload", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unload", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","unload", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  result = (Ogre::BackgroundProcessTicket)(arg1)->unload((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_unload(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_Ogre__ResourceBackgroundQueue, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ResourceBackgroundQueue_unload__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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_ResourceBackgroundQueue_unload__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceBackgroundQueue_unload__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceBackgroundQueue_unload__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ResourceBackgroundQueue.unload", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unload(Ogre::String const &resType, Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unload(Ogre::String const &resType, Ogre::String const &name)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unload(Ogre::String const &resType, Ogre::ResourceHandle handle, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unload(Ogre::String const &resType, Ogre::ResourceHandle handle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_unloadResourceGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg3 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","unloadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","unloadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unloadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","unloadResourceGroup", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp3);
  result = (Ogre::BackgroundProcessTicket)(arg1)->unloadResourceGroup((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_unloadResourceGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","unloadResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","unloadResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unloadResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BackgroundProcessTicket)(arg1)->unloadResourceGroup((Ogre::String const &)*arg2);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_unloadResourceGroup(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_Ogre__ResourceBackgroundQueue, 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_ResourceBackgroundQueue_unloadResourceGroup__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_ResourceBackgroundQueue_unloadResourceGroup__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ResourceBackgroundQueue.unloadResourceGroup", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unloadResourceGroup(Ogre::String const &name, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.unloadResourceGroup(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg7 = (Ogre::NameValuePairList *) 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg8 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  Ogre::BackgroundProcessTicket result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","prepare", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","prepare", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,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, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","prepare", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< Ogre::NameValuePairList * >(argp7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","prepare", 8, argv[6] )); 
  }
  arg8 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp8);
  result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7,arg8);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg7 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Ogre::BackgroundProcessTicket result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","prepare", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","prepare", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,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, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","prepare", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< Ogre::NameValuePairList * >(argp7);
  result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepare__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Ogre::BackgroundProcessTicket result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","prepare", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","prepare", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepare__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::BackgroundProcessTicket result;
  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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","prepare", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","prepare", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_prepare__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 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 &","prepare", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","prepare", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::BackgroundProcessTicket)(arg1)->prepare((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_prepare(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 9) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceBackgroundQueue_prepare__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ResourceBackgroundQueue_prepare__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ResourceBackgroundQueue_prepare__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, 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, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_ResourceBackgroundQueue_prepare__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, 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, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_ResourceBackgroundQueue_prepare__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "ResourceBackgroundQueue.prepare", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepare(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepare(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepare(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepare(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.prepare(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg7 = (Ogre::NameValuePairList *) 0 ;
  Ogre::ResourceBackgroundQueue::Listener *arg8 = (Ogre::ResourceBackgroundQueue::Listener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  void *argp8 = 0 ;
  int res8 = 0 ;
  Ogre::BackgroundProcessTicket result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","load", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","load", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,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, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","load", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< Ogre::NameValuePairList * >(argp7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8,SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0 |  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue::Listener *","load", 8, argv[6] )); 
  }
  arg8 = reinterpret_cast< Ogre::ResourceBackgroundQueue::Listener * >(argp8);
  result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7,arg8);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  Ogre::NameValuePairList *arg7 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  void *argp7 = 0 ;
  int res7 = 0 ;
  Ogre::BackgroundProcessTicket result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","load", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","load", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7,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, 0 |  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","load", 7, argv[5] )); 
  }
  arg7 = reinterpret_cast< Ogre::NameValuePairList * >(argp7);
  result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,(Ogre::NameValuePairList const *)arg7);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Ogre::BackgroundProcessTicket result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","load", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","load", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_load__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::BackgroundProcessTicket result;
  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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","load", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_load__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::BackgroundProcessTicket 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 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 &","load", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","load", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::BackgroundProcessTicket)(arg1)->load((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ResourceBackgroundQueue_load(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 9) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_ResourceBackgroundQueue_load__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_ResourceBackgroundQueue_load__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_ResourceBackgroundQueue_load__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, 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, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_ResourceBackgroundQueue_load__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, 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, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__ResourceBackgroundQueue__Listener, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_ResourceBackgroundQueue_load__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "ResourceBackgroundQueue.load", 
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.load(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams, Ogre::ResourceBackgroundQueue::Listener *listener)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.load(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader, Ogre::NameValuePairList const *loadParams)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.load(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.load(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group, bool isManual)\n"
    "    Ogre::BackgroundProcessTicket ResourceBackgroundQueue.load(Ogre::String const &resType, Ogre::String const &name, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_isProcessComplete(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::BackgroundProcessTicket arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long val2 ;
  int ecode2 = 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","isProcessComplete", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BackgroundProcessTicket","isProcessComplete", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BackgroundProcessTicket >(val2);
  result = (bool)(arg1)->isProcessComplete(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_abortRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::BackgroundProcessTicket arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","abortRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::BackgroundProcessTicket","abortRequest", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::BackgroundProcessTicket >(val2);
  (arg1)->abortRequest(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_canHandleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","canHandleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","canHandleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_handleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::WorkQueue::Response *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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","handleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","handleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_canHandleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","canHandleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","canHandleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_handleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *arg1 = (Ogre::ResourceBackgroundQueue *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 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_Ogre__ResourceBackgroundQueue, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceBackgroundQueue *","handleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceBackgroundQueue * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","handleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ResourceBackgroundQueue *) &Ogre::ResourceBackgroundQueue::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ResourceBackgroundQueue_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceBackgroundQueue *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ResourceBackgroundQueue *)Ogre::ResourceBackgroundQueue::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ResourceBackgroundQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRibbonTrail;

SWIGINTERN VALUE
_wrap_new_RibbonTrail__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  bool arg4 ;
  bool arg5 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RibbonTrail";
  Ogre::RibbonTrail *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",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 &","Ogre::RibbonTrail", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RibbonTrail", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::RibbonTrail", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::RibbonTrail", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::RibbonTrail", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::RibbonTrail", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2,arg3,arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RibbonTrail__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  bool arg4 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RibbonTrail";
  Ogre::RibbonTrail *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::RibbonTrail", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RibbonTrail", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::RibbonTrail", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::RibbonTrail", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::RibbonTrail", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RibbonTrail__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  size_t arg3 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RibbonTrail";
  Ogre::RibbonTrail *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::RibbonTrail", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RibbonTrail", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::RibbonTrail", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::RibbonTrail", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_RibbonTrail__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  size_t arg2 ;
  int res1 = SWIG_OLDOBJ ;
  size_t val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::RibbonTrail";
  Ogre::RibbonTrail *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::RibbonTrail", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RibbonTrail", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::RibbonTrail", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RibbonTrail__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::RibbonTrail";
  Ogre::RibbonTrail *result = 0 ;
  
  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 &","Ogre::RibbonTrail", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::RibbonTrail", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::RibbonTrail *)new Ogre::RibbonTrail((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_RibbonTrail(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 == 1) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_RibbonTrail__SWIG_4(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_RibbonTrail__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_RibbonTrail__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_RibbonTrail__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_RibbonTrail__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "RibbonTrail.new", 
    "    RibbonTrail.new(Ogre::String const &name, size_t maxElements, size_t numberOfChains, bool useTextureCoords, bool useColours)\n"
    "    RibbonTrail.new(Ogre::String const &name, size_t maxElements, size_t numberOfChains, bool useTextureCoords)\n"
    "    RibbonTrail.new(Ogre::String const &name, size_t maxElements, size_t numberOfChains)\n"
    "    RibbonTrail.new(Ogre::String const &name, size_t maxElements)\n"
    "    RibbonTrail.new(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_RibbonTrail(Ogre::RibbonTrail *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RibbonTrail_addNode(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","addNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","addNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->addNode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_removeNode(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","removeNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","removeNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->removeNode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getNodeIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstVectorIterator< Ogre::vector< Ogre::Node *,Ogre::STLAllocator< Ogre::Node *,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail const *","getNodeIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  result = ((Ogre::RibbonTrail const *)arg1)->getNodeIterator();
  vresult = SWIG_NewPointerObj((new Ogre::RibbonTrail::NodeIterator(static_cast< const Ogre::RibbonTrail::NodeIterator& >(result))), SWIGTYPE_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getChainIndexForNode(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","getChainIndexForNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node const *","getChainIndexForNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  result = (arg1)->getChainIndexForNode((Ogre::Node const *)arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setTrailLength(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setTrailLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTrailLength", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTrailLength(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getTrailLength(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail const *","getTrailLength", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  result = (Ogre::Real)((Ogre::RibbonTrail const *)arg1)->getTrailLength();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setMaxChainElements(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setMaxChainElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setMaxChainElements", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setMaxChainElements(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setNumberOfChains(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setNumberOfChains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setNumberOfChains", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setNumberOfChains(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_clearChain(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","clearChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","clearChain", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->clearChain(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setInitialColour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setInitialColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInitialColour", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setInitialColour", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setInitialColour", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->setInitialColour(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setInitialColour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  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 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setInitialColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInitialColour", 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","setInitialColour", 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","setInitialColour", 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","setInitialColour", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setInitialColour", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setInitialColour(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setInitialColour__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 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 ;
  
  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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setInitialColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInitialColour", 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","setInitialColour", 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","setInitialColour", 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","setInitialColour", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setInitialColour(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RibbonTrail_setInitialColour(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__RibbonTrail, 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__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RibbonTrail_setInitialColour__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RibbonTrail, 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_RibbonTrail_setInitialColour__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RibbonTrail, 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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_RibbonTrail_setInitialColour__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RibbonTrail.setInitialColour", 
    "    void RibbonTrail.setInitialColour(size_t chainIndex, Ogre::ColourValue const &col)\n"
    "    void RibbonTrail.setInitialColour(size_t chainIndex, Ogre::Real r, Ogre::Real g, Ogre::Real b, Ogre::Real a)\n"
    "    void RibbonTrail.setInitialColour(size_t chainIndex, Ogre::Real r, Ogre::Real g, Ogre::Real b)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getInitialColour(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue *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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail const *","getInitialColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getInitialColour", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::ColourValue *) &((Ogre::RibbonTrail const *)arg1)->getInitialColour(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setColourChange__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setColourChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setColourChange", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setColourChange", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setColourChange", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->setColourChange(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setInitialWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setInitialWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setInitialWidth", 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","setInitialWidth", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setInitialWidth(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getInitialWidth(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail const *","getInitialWidth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getInitialWidth", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Real)((Ogre::RibbonTrail const *)arg1)->getInitialWidth(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setWidthChange(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setWidthChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setWidthChange", 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","setWidthChange", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setWidthChange(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getWidthChange(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail const *","getWidthChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getWidthChange", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Real)((Ogre::RibbonTrail const *)arg1)->getWidthChange(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_setColourChange__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  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 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","setColourChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setColourChange", 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","setColourChange", 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","setColourChange", 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","setColourChange", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setColourChange", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setColourChange(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RibbonTrail_setColourChange(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__RibbonTrail, 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__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_RibbonTrail_setColourChange__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RibbonTrail, 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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_RibbonTrail_setColourChange__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "RibbonTrail.setColourChange", 
    "    void RibbonTrail.setColourChange(size_t chainIndex, Ogre::ColourValue const &valuePerSecond)\n"
    "    void RibbonTrail.setColourChange(size_t chainIndex, Ogre::Real r, Ogre::Real g, Ogre::Real b, Ogre::Real a)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getColourChange(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::ColourValue *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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail const *","getColourChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getColourChange", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::ColourValue *) &((Ogre::RibbonTrail const *)arg1)->getColourChange(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_nodeUpdated(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","nodeUpdated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node const *","nodeUpdated", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->nodeUpdated((Ogre::Node const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_nodeDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","nodeDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node const *","nodeDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->nodeDestroyed((Ogre::Node const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail__timeUpdate(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","_timeUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","_timeUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->_timeUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_getMovableType(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrail *arg1 = (Ogre::RibbonTrail *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrail const *","getMovableType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrail * >(argp1);
  result = (Ogre::String *) &((Ogre::RibbonTrail const *)arg1)->getMovableType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrail_cast(int argc, VALUE *argv, VALUE self) {
  VALUE arg1 = (VALUE) 0 ;
  Ogre::RibbonTrail *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  arg1 = argv[0];
  result = (Ogre::RibbonTrail *)Ogre_RibbonTrail_cast(arg1);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRibbonTrailFactory;

SWIGINTERN void
free_Ogre_RibbonTrailFactory(Ogre::RibbonTrailFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RibbonTrailFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::RibbonTrailFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_RibbonTrailFactory_FACTORY_TYPE_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::RibbonTrailFactory::FACTORY_TYPE_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::RibbonTrailFactory::FACTORY_TYPE_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrailFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrailFactory *arg1 = (Ogre::RibbonTrailFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__RibbonTrailFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrailFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrailFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::RibbonTrailFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RibbonTrailFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::RibbonTrailFactory *arg1 = (Ogre::RibbonTrailFactory *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__RibbonTrailFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RibbonTrailFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RibbonTrailFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassSceneNode;

SWIGINTERN VALUE
_wrap_new_SceneNode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::SceneNode";
  Ogre::SceneNode *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::SceneNode", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneNode *)new Ogre::SceneNode(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_SceneNode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::SceneNode";
  Ogre::SceneNode *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::SceneNode", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::SceneNode", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::SceneNode", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneNode *)new Ogre::SceneNode(arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_SceneNode(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__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_SceneNode__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_new_SceneNode__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "SceneNode.new", 
    "    SceneNode.new(Ogre::SceneManager *creator)\n"
    "    SceneNode.new(Ogre::SceneManager *creator, Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneNode(Ogre::SceneNode *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SceneNode_attachObject(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","attachObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","attachObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->attachObject(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_numAttachedObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","numAttachedObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (unsigned short)((Ogre::SceneNode const *)arg1)->numAttachedObjects();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getAttachedObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::MovableObject *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","getAttachedObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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","getAttachedObject", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::MovableObject *)(arg1)->getAttachedObject(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getAttachedObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","getAttachedObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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( "", "Ogre::String const &","getAttachedObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAttachedObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::MovableObject *)(arg1)->getAttachedObject((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_getAttachedObject(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_getAttachedObject__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_getAttachedObject__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.getAttachedObject", 
    "    Ogre::MovableObject * SceneNode.getAttachedObject(unsigned short index)\n"
    "    Ogre::MovableObject * SceneNode.getAttachedObject(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_detachObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::MovableObject *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","detachObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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","detachObject", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::MovableObject *)(arg1)->detachObject(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_detachObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","detachObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","detachObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->detachObject(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_detachObject__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","detachObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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( "", "Ogre::String const &","detachObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","detachObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::MovableObject *)(arg1)->detachObject((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_detachObject(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneNode_detachObject__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_detachObject__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_detachObject__SWIG_2(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.detachObject", 
    "    Ogre::MovableObject * SceneNode.detachObject(unsigned short index)\n"
    "    Ogre::MovableObject * SceneNode.detachObject(Ogre::MovableObject *obj)\n"
    "    Ogre::MovableObject * SceneNode.detachObject(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_detachAllObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","detachAllObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  (arg1)->detachAllObjects();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_isInSceneGraph(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","isInSceneGraph", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (bool)((Ogre::SceneNode const *)arg1)->isInSceneGraph();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__notifyRootNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_notifyRootNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  (arg1)->_notifyRootNode();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__update(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_update", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_update", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_update(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__updateBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_updateBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  (arg1)->_updateBounds();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__findVisibleObjects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::RenderQueue *arg3 = (Ogre::RenderQueue *) 0 ;
  Ogre::VisibleObjectsBoundsInfo *arg4 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  bool arg5 ;
  bool arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_findVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_findVisibleObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_findVisibleObjects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderQueue * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","_findVisibleObjects", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_findVisibleObjects", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","_findVisibleObjects", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","_findVisibleObjects", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->_findVisibleObjects(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__findVisibleObjects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::RenderQueue *arg3 = (Ogre::RenderQueue *) 0 ;
  Ogre::VisibleObjectsBoundsInfo *arg4 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  bool arg5 ;
  bool arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  bool val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_findVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_findVisibleObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_findVisibleObjects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderQueue * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","_findVisibleObjects", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_findVisibleObjects", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  ecode6 = SWIG_AsVal_bool(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "bool","_findVisibleObjects", 6, argv[4] ));
  } 
  arg6 = static_cast< bool >(val6);
  (arg1)->_findVisibleObjects(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__findVisibleObjects__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::RenderQueue *arg3 = (Ogre::RenderQueue *) 0 ;
  Ogre::VisibleObjectsBoundsInfo *arg4 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_findVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_findVisibleObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_findVisibleObjects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderQueue * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","_findVisibleObjects", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_findVisibleObjects", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->_findVisibleObjects(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__findVisibleObjects__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::RenderQueue *arg3 = (Ogre::RenderQueue *) 0 ;
  Ogre::VisibleObjectsBoundsInfo *arg4 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_findVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_findVisibleObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_findVisibleObjects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::RenderQueue * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","_findVisibleObjects", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp4);
  (arg1)->_findVisibleObjects(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode__findVisibleObjects(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneNode__findVisibleObjects__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SceneNode__findVisibleObjects__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneNode__findVisibleObjects__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__RenderQueue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_bool(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneNode__findVisibleObjects__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneNode._findVisibleObjects", 
    "    void SceneNode._findVisibleObjects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds, bool includeChildren, bool displayNodes, bool onlyShadowCasters)\n"
    "    void SceneNode._findVisibleObjects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds, bool includeChildren, bool displayNodes)\n"
    "    void SceneNode._findVisibleObjects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds, bool includeChildren)\n"
    "    void SceneNode._findVisibleObjects(Ogre::Camera *cam, Ogre::RenderQueue *queue, Ogre::VisibleObjectsBoundsInfo *visibleBounds)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__getWorldAABB(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","_getWorldAABB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::SceneNode const *)arg1)->_getWorldAABB();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getCreator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","getCreator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::SceneNode const *)arg1)->getCreator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_removeAndDestroyChild__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","removeAndDestroyChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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( "", "Ogre::String const &","removeAndDestroyChild", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeAndDestroyChild", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeAndDestroyChild((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_removeAndDestroyChild__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","removeAndDestroyChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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","removeAndDestroyChild", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->removeAndDestroyChild(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_removeAndDestroyChild(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_removeAndDestroyChild__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_removeAndDestroyChild__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.removeAndDestroyChild", 
    "    void SceneNode.removeAndDestroyChild(Ogre::String const &name)\n"
    "    void SceneNode.removeAndDestroyChild(unsigned short index)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_removeAndDestroyAllChildren(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","removeAndDestroyAllChildren", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  (arg1)->removeAndDestroyAllChildren();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_showBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","showBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","showBoundingBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->showBoundingBox(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_hideBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","hideBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","hideBoundingBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->hideBoundingBox(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__addBoundingBoxToQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::RenderQueue *arg2 = (Ogre::RenderQueue *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_addBoundingBoxToQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueue *","_addBoundingBoxToQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueue * >(argp2);
  (arg1)->_addBoundingBoxToQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getShowBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","getShowBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (bool)((Ogre::SceneNode const *)arg1)->getShowBoundingBox();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_createChildSceneNode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Quaternion *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","createChildSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 &","createChildSceneNode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChildSceneNode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createChildSceneNode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createChildSceneNode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Quaternion * >(argp3);
  result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::Vector3 const &)*arg2,(Ogre::Quaternion const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_createChildSceneNode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","createChildSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 &","createChildSceneNode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChildSceneNode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_createChildSceneNode__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","createChildSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::SceneNode *)(arg1)->createChildSceneNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_createChildSceneNode__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","createChildSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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( "", "Ogre::String const &","createChildSceneNode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createChildSceneNode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  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 &","createChildSceneNode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChildSceneNode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","createChildSceneNode", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","createChildSceneNode", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_createChildSceneNode__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","createChildSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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( "", "Ogre::String const &","createChildSceneNode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createChildSceneNode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  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 &","createChildSceneNode", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","createChildSceneNode", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::String const &)*arg2,(Ogre::Vector3 const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_createChildSceneNode__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","createChildSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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( "", "Ogre::String const &","createChildSceneNode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createChildSceneNode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneNode *)(arg1)->createChildSceneNode((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_createChildSceneNode(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneNode_createChildSceneNode__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_createChildSceneNode__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_createChildSceneNode__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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__Quaternion, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneNode_createChildSceneNode__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(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_SceneNode_createChildSceneNode__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(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__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneNode_createChildSceneNode__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneNode.createChildSceneNode", 
    "    Ogre::SceneNode * SceneNode.createChildSceneNode(Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::SceneNode * SceneNode.createChildSceneNode(Ogre::Vector3 const &translate)\n"
    "    Ogre::SceneNode * SceneNode.createChildSceneNode()\n"
    "    Ogre::SceneNode * SceneNode.createChildSceneNode(Ogre::String const &name, Ogre::Vector3 const &translate, Ogre::Quaternion const &rotate)\n"
    "    Ogre::SceneNode * SceneNode.createChildSceneNode(Ogre::String const &name, Ogre::Vector3 const &translate)\n"
    "    Ogre::SceneNode * SceneNode.createChildSceneNode(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_findLights__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::LightList *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::uint32 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","findLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LightList &","findLights", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LightList &","findLights", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::LightList * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","findLights", 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( "", "Ogre::uint32","findLights", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint32 >(val4);
  ((Ogre::SceneNode const *)arg1)->findLights(*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_findLights__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::LightList *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","findLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LightList &","findLights", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LightList &","findLights", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::LightList * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","findLights", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  ((Ogre::SceneNode const *)arg1)->findLights(*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_findLights(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneNode_findLights__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 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_unsigned_SS_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneNode_findLights__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneNode.findLights", 
    "    void SceneNode.findLights(Ogre::LightList &destList, Ogre::Real radius, Ogre::uint32 lightMask)\n"
    "    void SceneNode.findLights(Ogre::LightList &destList, Ogre::Real radius)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setFixedYawAxis__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setFixedYawAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFixedYawAxis", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(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 &","setFixedYawAxis", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setFixedYawAxis", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->setFixedYawAxis(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setFixedYawAxis__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setFixedYawAxis", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFixedYawAxis", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFixedYawAxis(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_setFixedYawAxis(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_setFixedYawAxis__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(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_SceneNode_setFixedYawAxis__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneNode.setFixedYawAxis", 
    "    void SceneNode.setFixedYawAxis(bool useFixed, Ogre::Vector3 const &fixedAxis)\n"
    "    void SceneNode.setFixedYawAxis(bool useFixed)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_yaw__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Radian *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","yaw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 const &","yaw", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","yaw", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Node::TransformSpace","yaw", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->yaw((Ogre::Radian const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_yaw__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Radian *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","yaw", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 const &","yaw", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Radian const &","yaw", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->yaw((Ogre::Radian const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_yaw(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneNode_yaw__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneNode_yaw__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneNode.yaw", 
    "    void SceneNode.yaw(Ogre::Radian const &angle, Ogre::Node::TransformSpace relativeTo)\n"
    "    void SceneNode.yaw(Ogre::Radian const &angle)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Node::TransformSpace arg5 ;
  Ogre::Vector3 *arg6 = 0 ;
  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 ;
  void *argp6 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDirection", 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","setDirection", 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","setDirection", 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( "", "Ogre::Node::TransformSpace","setDirection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Node::TransformSpace >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setDirection", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Vector3 * >(argp6);
  (arg1)->setDirection(arg2,arg3,arg4,arg5,(Ogre::Vector3 const &)*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Node::TransformSpace 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 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDirection", 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","setDirection", 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","setDirection", 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( "", "Ogre::Node::TransformSpace","setDirection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Node::TransformSpace >(val5);
  (arg1)->setDirection(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDirection__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDirection", 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","setDirection", 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","setDirection", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setDirection(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDirection__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 &","setDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 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( "", "Ogre::Node::TransformSpace","setDirection", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  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 &","setDirection", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->setDirection((Ogre::Vector3 const &)*arg2,arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDirection__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 &","setDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 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( "", "Ogre::Node::TransformSpace","setDirection", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->setDirection((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDirection__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Vector3 *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 &","setDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_setDirection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__SceneNode, 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_SceneNode_setDirection__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_setDirection__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneNode_setDirection__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_setDirection__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_setDirection__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SceneNode_setDirection__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneNode.setDirection", 
    "    void SceneNode.setDirection(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Node::TransformSpace relativeTo, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.setDirection(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Node::TransformSpace relativeTo)\n"
    "    void SceneNode.setDirection(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    void SceneNode.setDirection(Ogre::Vector3 const &vec, Ogre::Node::TransformSpace relativeTo, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.setDirection(Ogre::Vector3 const &vec, Ogre::Node::TransformSpace relativeTo)\n"
    "    void SceneNode.setDirection(Ogre::Vector3 const &vec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_lookAt__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","lookAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 &","lookAt", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","lookAt", 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( "", "Ogre::Node::TransformSpace","lookAt", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  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 &","lookAt", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","lookAt", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->lookAt((Ogre::Vector3 const &)*arg2,arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_lookAt__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Node::TransformSpace arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","lookAt", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(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 &","lookAt", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","lookAt", 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( "", "Ogre::Node::TransformSpace","lookAt", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Node::TransformSpace >(val3);
  (arg1)->lookAt((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_lookAt(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_Ogre__SceneNode, 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_SceneNode_lookAt__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneNode_lookAt__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneNode.lookAt", 
    "    void SceneNode.lookAt(Ogre::Vector3 const &targetPoint, Ogre::Node::TransformSpace relativeTo, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.lookAt(Ogre::Vector3 const &targetPoint, Ogre::Node::TransformSpace relativeTo)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setAutoTracking__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) (Ogre::SceneNode *)0 ;
  Ogre::Vector3 *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setAutoTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *const","setAutoTracking", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(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 &","setAutoTracking", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setAutoTracking", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","setAutoTracking", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setAutoTracking", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->setAutoTracking(arg2,arg3,(Ogre::Vector3 const &)*arg4,(Ogre::Vector3 const &)*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setAutoTracking__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) (Ogre::SceneNode *)0 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setAutoTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *const","setAutoTracking", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(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 &","setAutoTracking", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setAutoTracking", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->setAutoTracking(arg2,arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setAutoTracking__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) (Ogre::SceneNode *)0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setAutoTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *const","setAutoTracking", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(argp3);
  (arg1)->setAutoTracking(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setAutoTracking__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setAutoTracking", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setAutoTracking", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setAutoTracking(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_setAutoTracking(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_setAutoTracking__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneNode_setAutoTracking__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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_SceneNode_setAutoTracking__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneNode, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_SceneNode_setAutoTracking__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "SceneNode.setAutoTracking", 
    "    void SceneNode.setAutoTracking(bool enabled, Ogre::SceneNode *const target, Ogre::Vector3 const &localDirectionVector, Ogre::Vector3 const &offset)\n"
    "    void SceneNode.setAutoTracking(bool enabled, Ogre::SceneNode *const target, Ogre::Vector3 const &localDirectionVector)\n"
    "    void SceneNode.setAutoTracking(bool enabled, Ogre::SceneNode *const target)\n"
    "    void SceneNode.setAutoTracking(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getAutoTrackTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","getAutoTrackTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::SceneNode *)(arg1)->getAutoTrackTarget();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getAutoTrackOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","getAutoTrackOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::Vector3 *) &(arg1)->getAutoTrackOffset();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getAutoTrackLocalDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","getAutoTrackLocalDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::Vector3 *) &(arg1)->getAutoTrackLocalDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode__autoTrack(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_autoTrack", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  (arg1)->_autoTrack();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getParentSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","getParentSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::SceneNode *)((Ogre::SceneNode const *)arg1)->getParentSceneNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setVisible__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setVisible", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setVisible(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setVisible__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_setVisible(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_setVisible__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneNode_setVisible__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneNode.setVisible", 
    "    void SceneNode.setVisible(bool visible, bool cascade)\n"
    "    void SceneNode.setVisible(bool visible)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_flipVisibility__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","flipVisibility", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","flipVisibility", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->flipVisibility(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_flipVisibility__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","flipVisibility", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  (arg1)->flipVisibility();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_flipVisibility(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneNode_flipVisibility__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_flipVisibility__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneNode.flipVisibility", 
    "    void SceneNode.flipVisibility(bool cascade)\n"
    "    void SceneNode.flipVisibility()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDebugDisplayEnabled__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDebugDisplayEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDebugDisplayEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","setDebugDisplayEnabled", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->setDebugDisplayEnabled(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_setDebugDisplayEnabled__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","setDebugDisplayEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDebugDisplayEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDebugDisplayEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneNode_setDebugDisplayEnabled(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_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneNode_setDebugDisplayEnabled__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneNode_setDebugDisplayEnabled__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneNode.setDebugDisplayEnabled", 
    "    void SceneNode.setDebugDisplayEnabled(bool enabled, bool cascade)\n"
    "    void SceneNode.setDebugDisplayEnabled(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneNode_getDebugRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneNode *arg1 = (Ogre::SceneNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Node::DebugRenderable *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_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneNode *","getDebugRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneNode * >(argp1);
  result = (Ogre::Node::DebugRenderable *)(arg1)->getDebugRenderable();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Node__DebugRenderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSceneQuery;

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

SWIGINTERN VALUE
_wrap_new_SceneQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::SceneQuery";
  Ogre::SceneQuery *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::SceneQuery", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneQuery *)new Ogre::SceneQuery(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneQuery(Ogre::SceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SceneQuery_setQueryMask(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQuery *arg1 = (Ogre::SceneQuery *) 0 ;
  Ogre::uint32 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_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQuery *","setQueryMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQuery * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setQueryMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setQueryMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQuery_getQueryMask(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQuery *arg1 = (Ogre::SceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQuery const *","getQueryMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQuery * >(argp1);
  result = (Ogre::uint32)((Ogre::SceneQuery const *)arg1)->getQueryMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQuery_setQueryTypeMask(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQuery *arg1 = (Ogre::SceneQuery *) 0 ;
  Ogre::uint32 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_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQuery *","setQueryTypeMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQuery * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setQueryTypeMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setQueryTypeMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQuery_getQueryTypeMask(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQuery *arg1 = (Ogre::SceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQuery const *","getQueryTypeMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQuery * >(argp1);
  result = (Ogre::uint32)((Ogre::SceneQuery const *)arg1)->getQueryTypeMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQuery_setWorldFragmentType(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQuery *arg1 = (Ogre::SceneQuery *) 0 ;
  enum Ogre::SceneQuery::WorldFragmentType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQuery *","setWorldFragmentType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQuery * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "enum Ogre::SceneQuery::WorldFragmentType","setWorldFragmentType", 2, argv[0] ));
  } 
  arg2 = static_cast< enum Ogre::SceneQuery::WorldFragmentType >(val2);
  (arg1)->setWorldFragmentType(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQuery_getWorldFragmentType(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQuery *arg1 = (Ogre::SceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQuery::WorldFragmentType 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_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQuery const *","getWorldFragmentType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQuery * >(argp1);
  result = (Ogre::SceneQuery::WorldFragmentType)((Ogre::SceneQuery const *)arg1)->getWorldFragmentType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQuery_getSupportedWorldFragmentTypes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQuery *arg1 = (Ogre::SceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::set< Ogre::SceneQuery::WorldFragmentType,std::less< Ogre::SceneQuery::WorldFragmentType >,Ogre::STLAllocator< Ogre::SceneQuery::WorldFragmentType,Ogre::GeneralAllocPolicy > >::type *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_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQuery const *","getSupportedWorldFragmentTypes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQuery * >(argp1);
  result = (Ogre::set< Ogre::SceneQuery::WorldFragmentType,std::less< Ogre::SceneQuery::WorldFragmentType >,Ogre::STLAllocator< Ogre::SceneQuery::WorldFragmentType,Ogre::GeneralAllocPolicy > >::type *)((Ogre::SceneQuery const *)arg1)->getSupportedWorldFragmentTypes();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSceneQueryListener;

SWIGINTERN void
free_Ogre_SceneQueryListener(Ogre::SceneQueryListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SceneQueryListener_queryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQueryListener *arg1 = (Ogre::SceneQueryListener *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__SceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQueryListener *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQueryListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  result = (bool)(arg1)->queryResult(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQueryListener_queryResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQueryListener *arg1 = (Ogre::SceneQueryListener *) 0 ;
  Ogre::SceneQuery::WorldFragment *arg2 = (Ogre::SceneQuery::WorldFragment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__SceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQueryListener *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQueryListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQuery::WorldFragment *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQuery::WorldFragment * >(argp2);
  result = (bool)(arg1)->queryResult(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneQueryListener_queryResult(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_Ogre__SceneQueryListener, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneQueryListener_queryResult__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneQueryListener, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneQueryListener_queryResult__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneQueryListener.queryResult", 
    "    bool SceneQueryListener.queryResult(Ogre::MovableObject *object)\n"
    "    bool SceneQueryListener.queryResult(Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}


swig_class SwigClassSceneQueryResult;

SWIGINTERN VALUE
_wrap_SceneQueryResult_movables_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQueryResult *arg1 = (Ogre::SceneQueryResult *) 0 ;
  Ogre::SceneQueryResultMovableList *arg2 = (Ogre::SceneQueryResultMovableList *) 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_Ogre__SceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQueryResult *","movables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQueryResult * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryResultMovableList *","movables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryResultMovableList * >(argp2);
  if (arg1) (arg1)->movables = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQueryResult_movables_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQueryResult *arg1 = (Ogre::SceneQueryResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQueryResultMovableList *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_Ogre__SceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQueryResult *","movables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQueryResult * >(argp1);
  result = (Ogre::SceneQueryResultMovableList *)& ((arg1)->movables);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__MovableObject_p_Ogre__STLAllocatorT_Ogre__MovableObject_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQueryResult_worldFragments_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQueryResult *arg1 = (Ogre::SceneQueryResult *) 0 ;
  Ogre::SceneQueryResultWorldFragmentList *arg2 = (Ogre::SceneQueryResultWorldFragmentList *) 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_Ogre__SceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQueryResult *","worldFragments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQueryResult * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryResultWorldFragmentList *","worldFragments", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryResultWorldFragmentList * >(argp2);
  if (arg1) (arg1)->worldFragments = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneQueryResult_worldFragments_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneQueryResult *arg1 = (Ogre::SceneQueryResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQueryResultWorldFragmentList *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_Ogre__SceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneQueryResult *","worldFragments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneQueryResult * >(argp1);
  result = (Ogre::SceneQueryResultWorldFragmentList *)& ((arg1)->worldFragments);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__WorldFragment_p_Ogre__STLAllocatorT_Ogre__WorldFragment_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_SceneQueryResult(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SceneQueryResult";
  Ogre::SceneQueryResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SceneQueryResult *)new Ogre::SceneQueryResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneQueryResult(Ogre::SceneQueryResult *arg1) {
    delete arg1;
}

swig_class SwigClassRegionSceneQuery;

SWIGINTERN void
free_Ogre_RegionSceneQuery(Ogre::RegionSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RegionSceneQuery_execute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RegionSceneQuery *arg1 = (Ogre::RegionSceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQueryResult *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_Ogre__RegionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RegionSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RegionSceneQuery * >(argp1);
  result = (Ogre::SceneQueryResult *) &(arg1)->execute();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneQueryResult, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RegionSceneQuery_execute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RegionSceneQuery *arg1 = (Ogre::RegionSceneQuery *) 0 ;
  Ogre::SceneQueryListener *arg2 = (Ogre::SceneQueryListener *) 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_Ogre__RegionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RegionSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RegionSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RegionSceneQuery_execute(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_Ogre__RegionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RegionSceneQuery_execute__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RegionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneQueryListener, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RegionSceneQuery_execute__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RegionSceneQuery.execute", 
    "    void RegionSceneQuery.execute()\n"
    "    void RegionSceneQuery.execute(Ogre::SceneQueryListener *listener)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RegionSceneQuery_getLastResults(int argc, VALUE *argv, VALUE self) {
  Ogre::RegionSceneQuery *arg1 = (Ogre::RegionSceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQueryResult *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_Ogre__RegionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RegionSceneQuery const *","getLastResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RegionSceneQuery * >(argp1);
  result = (Ogre::SceneQueryResult *) &((Ogre::RegionSceneQuery const *)arg1)->getLastResults();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneQueryResult, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RegionSceneQuery_clearResults(int argc, VALUE *argv, VALUE self) {
  Ogre::RegionSceneQuery *arg1 = (Ogre::RegionSceneQuery *) 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_Ogre__RegionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RegionSceneQuery *","clearResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RegionSceneQuery * >(argp1);
  (arg1)->clearResults();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RegionSceneQuery_queryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RegionSceneQuery *arg1 = (Ogre::RegionSceneQuery *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__RegionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RegionSceneQuery *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RegionSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  result = (bool)(arg1)->queryResult(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RegionSceneQuery_queryResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RegionSceneQuery *arg1 = (Ogre::RegionSceneQuery *) 0 ;
  Ogre::SceneQuery::WorldFragment *arg2 = (Ogre::SceneQuery::WorldFragment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__RegionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RegionSceneQuery *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RegionSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQuery::WorldFragment *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQuery::WorldFragment * >(argp2);
  result = (bool)(arg1)->queryResult(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RegionSceneQuery_queryResult(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_Ogre__RegionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RegionSceneQuery_queryResult__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RegionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RegionSceneQuery_queryResult__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RegionSceneQuery.queryResult", 
    "    bool RegionSceneQuery.queryResult(Ogre::MovableObject *first)\n"
    "    bool RegionSceneQuery.queryResult(Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}


swig_class SwigClassAxisAlignedBoxSceneQuery;

SWIGINTERN void
free_Ogre_AxisAlignedBoxSceneQuery(Ogre::AxisAlignedBoxSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_AxisAlignedBoxSceneQuery_setBox(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBoxSceneQuery *arg1 = (Ogre::AxisAlignedBoxSceneQuery *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__AxisAlignedBoxSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBoxSceneQuery *","setBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBoxSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","setBox", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","setBox", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->setBox((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_AxisAlignedBoxSceneQuery_getBox(int argc, VALUE *argv, VALUE self) {
  Ogre::AxisAlignedBoxSceneQuery *arg1 = (Ogre::AxisAlignedBoxSceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__AxisAlignedBoxSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBoxSceneQuery const *","getBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::AxisAlignedBoxSceneQuery * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::AxisAlignedBoxSceneQuery const *)arg1)->getBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSphereSceneQuery;

SWIGINTERN void
free_Ogre_SphereSceneQuery(Ogre::SphereSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SphereSceneQuery_setSphere(int argc, VALUE *argv, VALUE self) {
  Ogre::SphereSceneQuery *arg1 = (Ogre::SphereSceneQuery *) 0 ;
  Ogre::Sphere *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_Ogre__SphereSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SphereSceneQuery *","setSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SphereSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","setSphere", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","setSphere", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  (arg1)->setSphere((Ogre::Sphere const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SphereSceneQuery_getSphere(int argc, VALUE *argv, VALUE self) {
  Ogre::SphereSceneQuery *arg1 = (Ogre::SphereSceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Sphere *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_Ogre__SphereSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SphereSceneQuery const *","getSphere", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SphereSceneQuery * >(argp1);
  result = (Ogre::Sphere *) &((Ogre::SphereSceneQuery const *)arg1)->getSphere();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPlaneBoundedVolumeListSceneQuery;

SWIGINTERN void
free_Ogre_PlaneBoundedVolumeListSceneQuery(Ogre::PlaneBoundedVolumeListSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PlaneBoundedVolumeListSceneQuery_setVolumes(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolumeListSceneQuery *arg1 = (Ogre::PlaneBoundedVolumeListSceneQuery *) 0 ;
  Ogre::PlaneBoundedVolumeList *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_Ogre__PlaneBoundedVolumeListSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolumeListSceneQuery *","setVolumes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolumeListSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolumeList const &","setVolumes", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PlaneBoundedVolumeList const &","setVolumes", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PlaneBoundedVolumeList * >(argp2);
  (arg1)->setVolumes((Ogre::PlaneBoundedVolumeList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PlaneBoundedVolumeListSceneQuery_getVolumes(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneBoundedVolumeListSceneQuery *arg1 = (Ogre::PlaneBoundedVolumeListSceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PlaneBoundedVolumeList *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_Ogre__PlaneBoundedVolumeListSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolumeListSceneQuery const *","getVolumes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneBoundedVolumeListSceneQuery * >(argp1);
  result = (Ogre::PlaneBoundedVolumeList *) &((Ogre::PlaneBoundedVolumeListSceneQuery const *)arg1)->getVolumes();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassRaySceneQueryListener;

SWIGINTERN void
free_Ogre_RaySceneQueryListener(Ogre::RaySceneQueryListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RaySceneQueryListener_queryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryListener *arg1 = (Ogre::RaySceneQueryListener *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__RaySceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryListener *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","queryResult", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQueryListener_queryResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryListener *arg1 = (Ogre::RaySceneQueryListener *) 0 ;
  Ogre::SceneQuery::WorldFragment *arg2 = (Ogre::SceneQuery::WorldFragment *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__RaySceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryListener *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQuery::WorldFragment *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQuery::WorldFragment * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","queryResult", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RaySceneQueryListener_queryResult(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RaySceneQueryListener, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RaySceneQueryListener_queryResult__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RaySceneQueryListener, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RaySceneQueryListener_queryResult__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RaySceneQueryListener.queryResult", 
    "    bool RaySceneQueryListener.queryResult(Ogre::MovableObject *obj, Ogre::Real distance)\n"
    "    bool RaySceneQueryListener.queryResult(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance)\n");
  
  return Qnil;
}


swig_class SwigClassRaySceneQueryResultEntry;

SWIGINTERN VALUE
_wrap_RaySceneQueryResultEntry_distance_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryResultEntry *arg1 = (Ogre::RaySceneQueryResultEntry *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__RaySceneQueryResultEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry *","distance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","distance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->distance = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQueryResultEntry_distance_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryResultEntry *arg1 = (Ogre::RaySceneQueryResultEntry *) 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_Ogre__RaySceneQueryResultEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry *","distance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp1);
  result = (Ogre::Real) ((arg1)->distance);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQueryResultEntry_movable_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryResultEntry *arg1 = (Ogre::RaySceneQueryResultEntry *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__RaySceneQueryResultEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry *","movable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","movable", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  if (arg1) (arg1)->movable = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQueryResultEntry_movable_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryResultEntry *arg1 = (Ogre::RaySceneQueryResultEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MovableObject *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_Ogre__RaySceneQueryResultEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry *","movable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp1);
  result = (Ogre::MovableObject *) ((arg1)->movable);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQueryResultEntry_worldFragment_set(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryResultEntry *arg1 = (Ogre::RaySceneQueryResultEntry *) 0 ;
  Ogre::SceneQuery::WorldFragment *arg2 = (Ogre::SceneQuery::WorldFragment *) 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_Ogre__RaySceneQueryResultEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry *","worldFragment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQuery::WorldFragment *","worldFragment", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQuery::WorldFragment * >(argp2);
  if (arg1) (arg1)->worldFragment = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQueryResultEntry_worldFragment_get(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryResultEntry *arg1 = (Ogre::RaySceneQueryResultEntry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQuery::WorldFragment *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_Ogre__RaySceneQueryResultEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry *","worldFragment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp1);
  result = (Ogre::SceneQuery::WorldFragment *) ((arg1)->worldFragment);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::RaySceneQueryResultEntry.<

  call-seq:
    <(rhs) -> bool

Lower than comparison operator.
*/
SWIGINTERN VALUE
_wrap_RaySceneQueryResultEntry___lt__(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQueryResultEntry *arg1 = (Ogre::RaySceneQueryResultEntry *) 0 ;
  Ogre::RaySceneQueryResultEntry *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_Ogre__RaySceneQueryResultEntry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry const *","operator <", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RaySceneQueryResultEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryResultEntry const &","operator <", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RaySceneQueryResultEntry const &","operator <", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RaySceneQueryResultEntry * >(argp2);
  result = (bool)((Ogre::RaySceneQueryResultEntry const *)arg1)->operator <((Ogre::RaySceneQueryResultEntry const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_RaySceneQueryResultEntry(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::RaySceneQueryResultEntry";
  Ogre::RaySceneQueryResultEntry *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::RaySceneQueryResultEntry *)new Ogre::RaySceneQueryResultEntry();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_RaySceneQueryResultEntry(Ogre::RaySceneQueryResultEntry *arg1) {
    delete arg1;
}

swig_class SwigClassRaySceneQuery;

SWIGINTERN void
free_Ogre_RaySceneQuery(Ogre::RaySceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_RaySceneQuery_setRay(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  Ogre::Ray *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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","setRay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","setRay", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","setRay", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  (arg1)->setRay((Ogre::Ray const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_getRay(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Ray *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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery const *","getRay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  result = (Ogre::Ray *) &((Ogre::RaySceneQuery const *)arg1)->getRay();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Ray, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_setSortByDistance__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  bool arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","setSortByDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSortByDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setSortByDistance", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setSortByDistance(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_setSortByDistance__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","setSortByDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSortByDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSortByDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RaySceneQuery_setSortByDistance(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_Ogre__RaySceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_RaySceneQuery_setSortByDistance__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RaySceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RaySceneQuery_setSortByDistance__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RaySceneQuery.setSortByDistance", 
    "    void RaySceneQuery.setSortByDistance(bool sort, Ogre::ushort maxresults)\n"
    "    void RaySceneQuery.setSortByDistance(bool sort)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_getSortByDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery const *","getSortByDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  result = (bool)((Ogre::RaySceneQuery const *)arg1)->getSortByDistance();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_getMaxResults(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery const *","getMaxResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  result = (Ogre::ushort)((Ogre::RaySceneQuery const *)arg1)->getMaxResults();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_execute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RaySceneQueryResult *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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  result = (Ogre::RaySceneQueryResult *) &(arg1)->execute();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_execute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  Ogre::RaySceneQueryListener *arg2 = (Ogre::RaySceneQueryListener *) 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RaySceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RaySceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RaySceneQuery_execute(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_Ogre__RaySceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_RaySceneQuery_execute__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RaySceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RaySceneQueryListener, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_RaySceneQuery_execute__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "RaySceneQuery.execute", 
    "    void RaySceneQuery.execute()\n"
    "    void RaySceneQuery.execute(Ogre::RaySceneQueryListener *listener)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_getLastResults(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RaySceneQueryResult *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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","getLastResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  result = (Ogre::RaySceneQueryResult *) &(arg1)->getLastResults();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RaySceneQueryResultEntry_Ogre__STLAllocatorT_Ogre__RaySceneQueryResultEntry_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_clearResults(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","clearResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  (arg1)->clearResults();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_queryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","queryResult", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_RaySceneQuery_queryResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::RaySceneQuery *arg1 = (Ogre::RaySceneQuery *) 0 ;
  Ogre::SceneQuery::WorldFragment *arg2 = (Ogre::SceneQuery::WorldFragment *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__RaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RaySceneQuery *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::RaySceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQuery::WorldFragment *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQuery::WorldFragment * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","queryResult", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_RaySceneQuery_queryResult(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RaySceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RaySceneQuery_queryResult__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__RaySceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_RaySceneQuery_queryResult__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "RaySceneQuery.queryResult", 
    "    bool RaySceneQuery.queryResult(Ogre::MovableObject *obj, Ogre::Real distance)\n"
    "    bool RaySceneQuery.queryResult(Ogre::SceneQuery::WorldFragment *fragment, Ogre::Real distance)\n");
  
  return Qnil;
}


swig_class SwigClassIntersectionSceneQueryListener;

SWIGINTERN void
free_Ogre_IntersectionSceneQueryListener(Ogre::IntersectionSceneQueryListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_IntersectionSceneQueryListener_queryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQueryListener *arg1 = (Ogre::IntersectionSceneQueryListener *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::MovableObject *arg3 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__IntersectionSceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryListener *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQueryListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::MovableObject * >(argp3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQueryListener_queryResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQueryListener *arg1 = (Ogre::IntersectionSceneQueryListener *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::SceneQuery::WorldFragment *arg3 = (Ogre::SceneQuery::WorldFragment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__IntersectionSceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryListener *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQueryListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneQuery::WorldFragment *","queryResult", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneQuery::WorldFragment * >(argp3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IntersectionSceneQueryListener_queryResult(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__IntersectionSceneQueryListener, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntersectionSceneQueryListener_queryResult__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__IntersectionSceneQueryListener, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntersectionSceneQueryListener_queryResult__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "IntersectionSceneQueryListener.queryResult", 
    "    bool IntersectionSceneQueryListener.queryResult(Ogre::MovableObject *first, Ogre::MovableObject *second)\n"
    "    bool IntersectionSceneQueryListener.queryResult(Ogre::MovableObject *movable, Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}


swig_class SwigClassIntersectionSceneQueryResult;

SWIGINTERN VALUE
_wrap_IntersectionSceneQueryResult_movables2movables_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQueryResult *arg1 = (Ogre::IntersectionSceneQueryResult *) 0 ;
  Ogre::SceneQueryMovableIntersectionList *arg2 = (Ogre::SceneQueryMovableIntersectionList *) 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_Ogre__IntersectionSceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryResult *","movables2movables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQueryResult * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryMovableIntersectionList *","movables2movables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryMovableIntersectionList * >(argp2);
  if (arg1) (arg1)->movables2movables = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQueryResult_movables2movables_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQueryResult *arg1 = (Ogre::IntersectionSceneQueryResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQueryMovableIntersectionList *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_Ogre__IntersectionSceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryResult *","movables2movables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQueryResult * >(argp1);
  result = (Ogre::SceneQueryMovableIntersectionList *)& ((arg1)->movables2movables);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectPair_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQueryResult_movables2world_set(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQueryResult *arg1 = (Ogre::IntersectionSceneQueryResult *) 0 ;
  Ogre::SceneQueryMovableWorldFragmentIntersectionList *arg2 = (Ogre::SceneQueryMovableWorldFragmentIntersectionList *) 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_Ogre__IntersectionSceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryResult *","movables2world", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQueryResult * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryMovableWorldFragmentIntersectionList *","movables2world", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryMovableWorldFragmentIntersectionList * >(argp2);
  if (arg1) (arg1)->movables2world = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQueryResult_movables2world_get(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQueryResult *arg1 = (Ogre::IntersectionSceneQueryResult *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneQueryMovableWorldFragmentIntersectionList *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_Ogre__IntersectionSceneQueryResult, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryResult *","movables2world", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQueryResult * >(argp1);
  result = (Ogre::SceneQueryMovableWorldFragmentIntersectionList *)& ((arg1)->movables2world);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__listT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__STLAllocatorT_Ogre__SceneQueryMovableObjectWorldFragmentPair_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_IntersectionSceneQueryResult(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::IntersectionSceneQueryResult";
  Ogre::IntersectionSceneQueryResult *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::IntersectionSceneQueryResult *)new Ogre::IntersectionSceneQueryResult();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_IntersectionSceneQueryResult(Ogre::IntersectionSceneQueryResult *arg1) {
    delete arg1;
}

swig_class SwigClassIntersectionSceneQuery;

SWIGINTERN void
free_Ogre_IntersectionSceneQuery(Ogre::IntersectionSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_execute__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQuery *arg1 = (Ogre::IntersectionSceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IntersectionSceneQueryResult *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_Ogre__IntersectionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQuery * >(argp1);
  result = (Ogre::IntersectionSceneQueryResult *) &(arg1)->execute();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IntersectionSceneQueryResult, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_execute__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQuery *arg1 = (Ogre::IntersectionSceneQuery *) 0 ;
  Ogre::IntersectionSceneQueryListener *arg2 = (Ogre::IntersectionSceneQueryListener *) 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_Ogre__IntersectionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IntersectionSceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IntersectionSceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IntersectionSceneQuery_execute(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_Ogre__IntersectionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_IntersectionSceneQuery_execute__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__IntersectionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__IntersectionSceneQueryListener, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_IntersectionSceneQuery_execute__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "IntersectionSceneQuery.execute", 
    "    void IntersectionSceneQuery.execute()\n"
    "    void IntersectionSceneQuery.execute(Ogre::IntersectionSceneQueryListener *listener)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_getLastResults(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQuery *arg1 = (Ogre::IntersectionSceneQuery *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IntersectionSceneQueryResult *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_Ogre__IntersectionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQuery const *","getLastResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQuery * >(argp1);
  result = (Ogre::IntersectionSceneQueryResult *) &((Ogre::IntersectionSceneQuery const *)arg1)->getLastResults();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IntersectionSceneQueryResult, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_clearResults(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQuery *arg1 = (Ogre::IntersectionSceneQuery *) 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_Ogre__IntersectionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQuery *","clearResults", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQuery * >(argp1);
  (arg1)->clearResults();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_queryResult__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQuery *arg1 = (Ogre::IntersectionSceneQuery *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::MovableObject *arg3 = (Ogre::MovableObject *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__IntersectionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQuery *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::MovableObject * >(argp3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_IntersectionSceneQuery_queryResult__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::IntersectionSceneQuery *arg1 = (Ogre::IntersectionSceneQuery *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 0 ;
  Ogre::SceneQuery::WorldFragment *arg3 = (Ogre::SceneQuery::WorldFragment *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__IntersectionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQuery *","queryResult", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::IntersectionSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","queryResult", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneQuery::WorldFragment *","queryResult", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneQuery::WorldFragment * >(argp3);
  result = (bool)(arg1)->queryResult(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_IntersectionSceneQuery_queryResult(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__IntersectionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntersectionSceneQuery_queryResult__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__IntersectionSceneQuery, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneQuery__WorldFragment, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_IntersectionSceneQuery_queryResult__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "IntersectionSceneQuery.queryResult", 
    "    bool IntersectionSceneQuery.queryResult(Ogre::MovableObject *first, Ogre::MovableObject *second)\n"
    "    bool IntersectionSceneQuery.queryResult(Ogre::MovableObject *movable, Ogre::SceneQuery::WorldFragment *fragment)\n");
  
  return Qnil;
}


swig_class SwigClassShadowTextureConfig;

SWIGINTERN VALUE
_wrap_ShadowTextureConfig_width_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","width", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(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","width", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->width = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_width_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","width", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  result = (unsigned int) ((arg1)->width);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_height_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","height", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(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","height", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->height = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_height_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","height", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  result = (unsigned int) ((arg1)->height);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_format_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","format", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","format", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  if (arg1) (arg1)->format = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_format_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","format", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  result = (Ogre::PixelFormat) ((arg1)->format);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_fsaa_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","fsaa", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(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","fsaa", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  if (arg1) (arg1)->fsaa = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_fsaa_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","fsaa", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  result = (unsigned int) ((arg1)->fsaa);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_depthBufferPoolId_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","depthBufferPoolId", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","depthBufferPoolId", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  if (arg1) (arg1)->depthBufferPoolId = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureConfig_depthBufferPoolId_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = (Ogre::ShadowTextureConfig *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__ShadowTextureConfig, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig *","depthBufferPoolId", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  result = (Ogre::uint16) ((arg1)->depthBufferPoolId);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ShadowTextureConfig(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ShadowTextureConfig";
  Ogre::ShadowTextureConfig *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ShadowTextureConfig *)new Ogre::ShadowTextureConfig();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ShadowTextureConfig(Ogre::ShadowTextureConfig *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::Ogre.==

  call-seq:
    ==(left, right) -> bool
    ==(left, right) -> bool
    ==(lhs, rhs) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap___eq____SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureConfig *arg1 = 0 ;
  Ogre::ShadowTextureConfig *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool 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__ShadowTextureConfig,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig const &","Ogre::operator ==", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ShadowTextureConfig const &","Ogre::operator ==", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__ShadowTextureConfig,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig const &","Ogre::operator ==", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ShadowTextureConfig const &","Ogre::operator ==", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp2);
  result = (bool)Ogre::operator ==((Ogre::ShadowTextureConfig const &)*arg1,(Ogre::ShadowTextureConfig const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap___eq__(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__UTFString___const_fwd_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_fwd_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__UTFString___const_rev_iterator, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ShadowTextureConfig, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ShadowTextureConfig, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap___eq____SWIG_5(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "__eq__", 
    "    bool __eq__(Ogre::UTFString::_const_fwd_iterator const &left, Ogre::UTFString::_const_fwd_iterator const &right)\n"
    "    bool __eq__(Ogre::UTFString::_const_rev_iterator const &left, Ogre::UTFString::_const_rev_iterator const &right)\n"
    "    bool __eq__(Ogre::ShadowTextureConfig const &lhs, Ogre::ShadowTextureConfig const &rhs)\n");
  
  return Qnil;
}


swig_class SwigClassShadowTextureManager;

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

SWIGINTERN VALUE
_wrap_new_ShadowTextureManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ShadowTextureManager";
  Ogre::ShadowTextureManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ShadowTextureManager *)new Ogre::ShadowTextureManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ShadowTextureManager(Ogre::ShadowTextureManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ShadowTextureManager_getShadowTextures(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureManager *arg1 = (Ogre::ShadowTextureManager *) 0 ;
  Ogre::ShadowTextureConfigList *arg2 = 0 ;
  Ogre::ShadowTextureList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__ShadowTextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureManager *","getShadowTextures", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__ShadowTextureConfig_Ogre__STLAllocatorT_Ogre__ShadowTextureConfig_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfigList const &","getShadowTextures", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ShadowTextureConfigList const &","getShadowTextures", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ShadowTextureConfigList * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ShadowTextureList &","getShadowTextures", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ShadowTextureList &","getShadowTextures", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ShadowTextureList * >(argp3);
  (arg1)->getShadowTextures((Ogre::ShadowTextureConfigList const &)*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureManager_getNullShadowTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureManager *arg1 = (Ogre::ShadowTextureManager *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::TexturePtr 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_Ogre__ShadowTextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureManager *","getNullShadowTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","getNullShadowTexture", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  result = (arg1)->getNullShadowTexture(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureManager_clearUnused(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureManager *arg1 = (Ogre::ShadowTextureManager *) 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_Ogre__ShadowTextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureManager *","clearUnused", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureManager * >(argp1);
  (arg1)->clearUnused();
  return Qnil;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::ShadowTextureManager.clear

  call-seq:
    clear

Clear ShadowTextureManager contents.
*/
SWIGINTERN VALUE
_wrap_ShadowTextureManager_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureManager *arg1 = (Ogre::ShadowTextureManager *) 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_Ogre__ShadowTextureManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ShadowTextureManager *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ShadowTextureManager * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ShadowTextureManager *) &Ogre::ShadowTextureManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ShadowTextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowTextureManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::ShadowTextureManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ShadowTextureManager *)Ogre::ShadowTextureManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ShadowTextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassViewPoint;

SWIGINTERN VALUE
_wrap_ViewPoint_position_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ViewPoint *arg1 = (Ogre::ViewPoint *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__ViewPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ViewPoint *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ViewPoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","position", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  if (arg1) (arg1)->position = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ViewPoint_position_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ViewPoint *arg1 = (Ogre::ViewPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__ViewPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ViewPoint *","position", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ViewPoint * >(argp1);
  result = (Ogre::Vector3 *)& ((arg1)->position);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ViewPoint_orientation_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ViewPoint *arg1 = (Ogre::ViewPoint *) 0 ;
  Ogre::Quaternion *arg2 = (Ogre::Quaternion *) 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_Ogre__ViewPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ViewPoint *","orientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ViewPoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion *","orientation", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  if (arg1) (arg1)->orientation = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ViewPoint_orientation_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ViewPoint *arg1 = (Ogre::ViewPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Quaternion *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_Ogre__ViewPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ViewPoint *","orientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ViewPoint * >(argp1);
  result = (Ogre::Quaternion *)& ((arg1)->orientation);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ViewPoint(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ViewPoint";
  Ogre::ViewPoint *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ViewPoint *)new Ogre::ViewPoint();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ViewPoint(Ogre::ViewPoint *arg1) {
    delete arg1;
}

swig_class SwigClassVisibleObjectsBoundsInfo;

SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_aabb_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::AxisAlignedBox *arg2 = (Ogre::AxisAlignedBox *) 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","aabb", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","aabb", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  if (arg1) (arg1)->aabb = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_aabb_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","aabb", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  result = (Ogre::AxisAlignedBox *)& ((arg1)->aabb);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_receiverAabb_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::AxisAlignedBox *arg2 = (Ogre::AxisAlignedBox *) 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","receiverAabb", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","receiverAabb", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  if (arg1) (arg1)->receiverAabb = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_receiverAabb_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","receiverAabb", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  result = (Ogre::AxisAlignedBox *)& ((arg1)->receiverAabb);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_minDistance_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","minDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","minDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->minDistance = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_minDistance_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","minDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  result = (Ogre::Real) ((arg1)->minDistance);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_maxDistance_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","maxDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","maxDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->maxDistance = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_maxDistance_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","maxDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  result = (Ogre::Real) ((arg1)->maxDistance);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_minDistanceInFrustum_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","minDistanceInFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","minDistanceInFrustum", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->minDistanceInFrustum = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_minDistanceInFrustum_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","minDistanceInFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  result = (Ogre::Real) ((arg1)->minDistanceInFrustum);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_maxDistanceInFrustum_set(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","maxDistanceInFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","maxDistanceInFrustum", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  if (arg1) (arg1)->maxDistanceInFrustum = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_maxDistanceInFrustum_get(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","maxDistanceInFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  result = (Ogre::Real) ((arg1)->maxDistanceInFrustum);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_VisibleObjectsBoundsInfo(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::VisibleObjectsBoundsInfo";
  Ogre::VisibleObjectsBoundsInfo *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::VisibleObjectsBoundsInfo *)new Ogre::VisibleObjectsBoundsInfo();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_merge__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::Sphere *arg3 = 0 ;
  Ogre::Camera *arg4 = (Ogre::Camera *) 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","merge", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","merge", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Sphere const &","merge", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","merge", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Sphere * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Camera const *","merge", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Camera * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","merge", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->merge((Ogre::AxisAlignedBox const &)*arg2,(Ogre::Sphere const &)*arg3,(Ogre::Camera const *)arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_merge__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::Sphere *arg3 = 0 ;
  Ogre::Camera *arg4 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","merge", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","merge", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","merge", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Sphere const &","merge", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","merge", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Sphere * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Camera const *","merge", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Camera * >(argp4);
  (arg1)->merge((Ogre::AxisAlignedBox const &)*arg2,(Ogre::Sphere const &)*arg3,(Ogre::Camera const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_VisibleObjectsBoundsInfo_merge(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_VisibleObjectsBoundsInfo_merge__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_VisibleObjectsBoundsInfo_merge__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "VisibleObjectsBoundsInfo.merge", 
    "    void VisibleObjectsBoundsInfo.merge(Ogre::AxisAlignedBox const &boxBounds, Ogre::Sphere const &sphereBounds, Ogre::Camera const *cam, bool receiver)\n"
    "    void VisibleObjectsBoundsInfo.merge(Ogre::AxisAlignedBox const &boxBounds, Ogre::Sphere const &sphereBounds, Ogre::Camera const *cam)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_VisibleObjectsBoundsInfo_mergeNonRenderedButInFrustum(int argc, VALUE *argv, VALUE self) {
  Ogre::VisibleObjectsBoundsInfo *arg1 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::Sphere *arg3 = 0 ;
  Ogre::Camera *arg4 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","mergeNonRenderedButInFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","mergeNonRenderedButInFrustum", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","mergeNonRenderedButInFrustum", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Sphere const &","mergeNonRenderedButInFrustum", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","mergeNonRenderedButInFrustum", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Sphere * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Camera const *","mergeNonRenderedButInFrustum", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Camera * >(argp4);
  (arg1)->mergeNonRenderedButInFrustum((Ogre::AxisAlignedBox const &)*arg2,(Ogre::Sphere const &)*arg3,(Ogre::Camera const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_VisibleObjectsBoundsInfo(Ogre::VisibleObjectsBoundsInfo *arg1) {
    delete arg1;
}

swig_class SwigClassSceneManager;

SWIGINTERN VALUE
_wrap_SceneManager_WORLD_GEOMETRY_TYPE_MASK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SceneManager::WORLD_GEOMETRY_TYPE_MASK));
  return _val;
}


SWIGINTERN VALUE
_wrap_SceneManager_WORLD_GEOMETRY_TYPE_MASK_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SceneManager::WORLD_GEOMETRY_TYPE_MASK""' of type '""Ogre::uint32""'");
    }
    Ogre::SceneManager::WORLD_GEOMETRY_TYPE_MASK = static_cast< Ogre::uint32 >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_ENTITY_TYPE_MASK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SceneManager::ENTITY_TYPE_MASK));
  return _val;
}


SWIGINTERN VALUE
_wrap_SceneManager_ENTITY_TYPE_MASK_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SceneManager::ENTITY_TYPE_MASK""' of type '""Ogre::uint32""'");
    }
    Ogre::SceneManager::ENTITY_TYPE_MASK = static_cast< Ogre::uint32 >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_FX_TYPE_MASK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SceneManager::FX_TYPE_MASK));
  return _val;
}


SWIGINTERN VALUE
_wrap_SceneManager_FX_TYPE_MASK_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SceneManager::FX_TYPE_MASK""' of type '""Ogre::uint32""'");
    }
    Ogre::SceneManager::FX_TYPE_MASK = static_cast< Ogre::uint32 >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_STATICGEOMETRY_TYPE_MASK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SceneManager::STATICGEOMETRY_TYPE_MASK));
  return _val;
}


SWIGINTERN VALUE
_wrap_SceneManager_STATICGEOMETRY_TYPE_MASK_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SceneManager::STATICGEOMETRY_TYPE_MASK""' of type '""Ogre::uint32""'");
    }
    Ogre::SceneManager::STATICGEOMETRY_TYPE_MASK = static_cast< Ogre::uint32 >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_LIGHT_TYPE_MASK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SceneManager::LIGHT_TYPE_MASK));
  return _val;
}


SWIGINTERN VALUE
_wrap_SceneManager_LIGHT_TYPE_MASK_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SceneManager::LIGHT_TYPE_MASK""' of type '""Ogre::uint32""'");
    }
    Ogre::SceneManager::LIGHT_TYPE_MASK = static_cast< Ogre::uint32 >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_FRUSTUM_TYPE_MASK_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SceneManager::FRUSTUM_TYPE_MASK));
  return _val;
}


SWIGINTERN VALUE
_wrap_SceneManager_FRUSTUM_TYPE_MASK_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SceneManager::FRUSTUM_TYPE_MASK""' of type '""Ogre::uint32""'");
    }
    Ogre::SceneManager::FRUSTUM_TYPE_MASK = static_cast< Ogre::uint32 >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_USER_TYPE_MASK_LIMIT_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SceneManager::USER_TYPE_MASK_LIMIT));
  return _val;
}


SWIGINTERN VALUE
_wrap_SceneManager_USER_TYPE_MASK_LIMIT_set(VALUE self, VALUE _val) {
  {
    unsigned int val;
    int res = SWIG_AsVal_unsigned_SS_int(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SceneManager::USER_TYPE_MASK_LIMIT""' of type '""Ogre::uint32""'");
    }
    Ogre::SceneManager::USER_TYPE_MASK_LIMIT = static_cast< Ogre::uint32 >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepareShadowTextures__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg3 = (Ogre::Viewport *) 0 ;
  Ogre::LightList *arg4 = (Ogre::LightList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","prepareShadowTextures", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","prepareShadowTextures", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Viewport *","prepareShadowTextures", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Viewport * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::LightList const *","prepareShadowTextures", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::LightList * >(argp4);
  (arg1)->prepareShadowTextures(arg2,arg3,(Ogre::LightList const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepareShadowTextures__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg3 = (Ogre::Viewport *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","prepareShadowTextures", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","prepareShadowTextures", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Viewport *","prepareShadowTextures", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Viewport * >(argp3);
  (arg1)->prepareShadowTextures(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_prepareShadowTextures(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneManager_prepareShadowTextures__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager_prepareShadowTextures__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.prepareShadowTextures", 
    "    void SceneManager.prepareShadowTextures(Ogre::Camera *cam, Ogre::Viewport *vp, Ogre::LightList const *lightList)\n"
    "    void SceneManager.prepareShadowTextures(Ogre::Camera *cam, Ogre::Viewport *vp)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__pauseRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager::RenderContext *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_pauseRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneManager::RenderContext *)(arg1)->_pauseRendering();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__RenderContext, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__resumeRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneManager::RenderContext *arg2 = (Ogre::SceneManager::RenderContext *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_resumeRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager__RenderContext, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager::RenderContext *","_resumeRendering", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager::RenderContext * >(argp2);
  (arg1)->_resumeRendering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneManager(Ogre::SceneManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SceneManager_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::String *) &((Ogre::SceneManager const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::String *) &((Ogre::SceneManager const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Camera *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createCamera", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createCamera", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Camera *)(arg1)->createCamera((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Camera *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getCamera", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getCamera", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Camera *)((Ogre::SceneManager const *)arg1)->getCamera((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasCamera", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasCamera", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasCamera((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyCamera__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","destroyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->destroyCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyCamera__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyCamera", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyCamera", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyCamera((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyCamera(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Camera, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyCamera__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyCamera__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyCamera", 
    "    void SceneManager.destroyCamera(Ogre::Camera *cam)\n"
    "    void SceneManager.destroyCamera(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllCameras(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllCameras", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllCameras();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createLight__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Light *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createLight", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createLight", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Light *)(arg1)->createLight((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createLight__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Light *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Light *)(arg1)->createLight();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Light, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createLight(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createLight__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createLight__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.createLight", 
    "    Ogre::Light * SceneManager.createLight(Ogre::String const &name)\n"
    "    Ogre::Light * SceneManager.createLight()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getLight(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Light *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getLight", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getLight", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Light *)((Ogre::SceneManager const *)arg1)->getLight((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasLight(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasLight", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasLight", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasLight((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getLightClippingPlanes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Light *arg2 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::PlaneList *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getLightClippingPlanes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light *","getLightClippingPlanes", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  result = (Ogre::PlaneList *) &(arg1)->getLightClippingPlanes(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getLightScissorRect(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Light *arg2 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::RealRect *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getLightScissorRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light *","getLightScissorRect", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getLightScissorRect", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  result = (Ogre::RealRect *) &(arg1)->getLightScissorRect(arg2,(Ogre::Camera const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TRectT_float_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyLight__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyLight", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyLight", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyLight((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyLight__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Light *arg2 = (Ogre::Light *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light *","destroyLight", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  (arg1)->destroyLight(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyLight(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Light, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyLight__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyLight__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyLight", 
    "    void SceneManager.destroyLight(Ogre::String const &name)\n"
    "    void SceneManager.destroyLight(Ogre::Light *light)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllLights(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllLights();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__notifyLightsDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_notifyLightsDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->_notifyLightsDirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__getLightsDirtyCounter(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ulong 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","_getLightsDirtyCounter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ulong)((Ogre::SceneManager const *)arg1)->_getLightsDirtyCounter();
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__getLightsAffectingFrustum(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","_getLightsAffectingFrustum", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::LightList *) &((Ogre::SceneManager const *)arg1)->_getLightsAffectingFrustum();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__populateLightList__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::LightList *arg4 = 0 ;
  Ogre::uint32 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_populateLightList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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 &","_populateLightList", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","_populateLightList", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_populateLightList", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::LightList &","_populateLightList", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LightList &","_populateLightList", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::LightList * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint32","_populateLightList", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint32 >(val5);
  (arg1)->_populateLightList((Ogre::Vector3 const &)*arg2,arg3,*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__populateLightList__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Real arg3 ;
  Ogre::LightList *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_populateLightList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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 &","_populateLightList", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","_populateLightList", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_populateLightList", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::LightList &","_populateLightList", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LightList &","_populateLightList", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::LightList * >(argp4);
  (arg1)->_populateLightList((Ogre::Vector3 const &)*arg2,arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__populateLightList__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 0 ;
  Ogre::Real arg3 ;
  Ogre::LightList *arg4 = 0 ;
  Ogre::uint32 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_populateLightList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","_populateLightList", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_populateLightList", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::LightList &","_populateLightList", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LightList &","_populateLightList", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::LightList * >(argp4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint32","_populateLightList", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint32 >(val5);
  (arg1)->_populateLightList((Ogre::SceneNode const *)arg2,arg3,*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__populateLightList__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 0 ;
  Ogre::Real arg3 ;
  Ogre::LightList *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_populateLightList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","_populateLightList", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","_populateLightList", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::LightList &","_populateLightList", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::LightList &","_populateLightList", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::LightList * >(argp4);
  (arg1)->_populateLightList((Ogre::SceneNode const *)arg2,arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__populateLightList(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager__populateLightList__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager__populateLightList__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SceneManager__populateLightList__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SceneManager__populateLightList__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "SceneManager._populateLightList", 
    "    void SceneManager._populateLightList(Ogre::Vector3 const &position, Ogre::Real radius, Ogre::LightList &destList, Ogre::uint32 lightMask)\n"
    "    void SceneManager._populateLightList(Ogre::Vector3 const &position, Ogre::Real radius, Ogre::LightList &destList)\n"
    "    void SceneManager._populateLightList(Ogre::SceneNode const *sn, Ogre::Real radius, Ogre::LightList &destList, Ogre::uint32 lightMask)\n"
    "    void SceneManager._populateLightList(Ogre::SceneNode const *sn, Ogre::Real radius, Ogre::LightList &destList)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createSceneNode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneNode *)(arg1)->createSceneNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createSceneNode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneNode *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createSceneNode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneNode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneNode *)(arg1)->createSceneNode((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createSceneNode(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createSceneNode__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createSceneNode__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.createSceneNode", 
    "    Ogre::SceneNode * SceneManager.createSceneNode()\n"
    "    Ogre::SceneNode * SceneManager.createSceneNode(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroySceneNode__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroySceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroySceneNode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroySceneNode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroySceneNode((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroySceneNode__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroySceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode *","destroySceneNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  (arg1)->destroySceneNode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroySceneNode(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneNode, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroySceneNode__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroySceneNode__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroySceneNode", 
    "    void SceneManager.destroySceneNode(Ogre::String const &name)\n"
    "    void SceneManager.destroySceneNode(Ogre::SceneNode *sn)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getRootSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getRootSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneNode *)(arg1)->getRootSceneNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneNode *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getSceneNode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSceneNode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSceneNode((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasSceneNode", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasSceneNode", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasSceneNode((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createEntity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 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 &","createEntity", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createEntity", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createEntity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 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 &","createEntity", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  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_SceneManager_createEntity__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::MeshPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 ;
  int res3 = 0 ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__MeshPtr,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::MeshPtr const &","createEntity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshPtr const &","createEntity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::MeshPtr * >(argp3);
  result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,(Ogre::MeshPtr const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createEntity__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createEntity__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::MeshPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MeshPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MeshPtr const &","createEntity", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MeshPtr const &","createEntity", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MeshPtr * >(argp2);
  result = (Ogre::Entity *)(arg1)->createEntity((Ogre::MeshPtr const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createEntity__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::SceneManager::PrefabType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int val3 ;
  int ecode3 = 0 ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneManager::PrefabType","createEntity", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneManager::PrefabType >(val3);
  result = (Ogre::Entity *)(arg1)->createEntity((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createEntity__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneManager::PrefabType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneManager::PrefabType","createEntity", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneManager::PrefabType >(val2);
  result = (Ogre::Entity *)(arg1)->createEntity(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createEntity(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MeshPtr, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_createEntity__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneManager_createEntity__SWIG_6(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createEntity__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__MeshPtr, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneManager_createEntity__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_createEntity__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createEntity__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager_createEntity__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.createEntity", 
    "    Ogre::Entity * SceneManager.createEntity(Ogre::String const &entityName, Ogre::String const &meshName, Ogre::String const &groupName)\n"
    "    Ogre::Entity * SceneManager.createEntity(Ogre::String const &entityName, Ogre::String const &meshName)\n"
    "    Ogre::Entity * SceneManager.createEntity(Ogre::String const &entityName, Ogre::MeshPtr const &pMesh)\n"
    "    Ogre::Entity * SceneManager.createEntity(Ogre::String const &meshName)\n"
    "    Ogre::Entity * SceneManager.createEntity(Ogre::MeshPtr const &pMesh)\n"
    "    Ogre::Entity * SceneManager.createEntity(Ogre::String const &entityName, Ogre::SceneManager::PrefabType ptype)\n"
    "    Ogre::Entity * SceneManager.createEntity(Ogre::SceneManager::PrefabType ptype)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Entity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Entity *)((Ogre::SceneManager const *)arg1)->getEntity((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasEntity((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyEntity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","destroyEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(argp2);
  (arg1)->destroyEntity(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyEntity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyEntity", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyEntity((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyEntity(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyEntity__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyEntity__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyEntity", 
    "    void SceneManager.destroyEntity(Ogre::Entity *ent)\n"
    "    void SceneManager.destroyEntity(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllEntities(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllEntities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllEntities();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createManualObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ManualObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createManualObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createManualObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createManualObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ManualObject *)(arg1)->createManualObject((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createManualObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ManualObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createManualObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ManualObject *)(arg1)->createManualObject();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createManualObject(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createManualObject__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createManualObject__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.createManualObject", 
    "    Ogre::ManualObject * SceneManager.createManualObject(Ogre::String const &name)\n"
    "    Ogre::ManualObject * SceneManager.createManualObject()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getManualObject(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ManualObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getManualObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getManualObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getManualObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ManualObject *)((Ogre::SceneManager const *)arg1)->getManualObject((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ManualObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasManualObject(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasManualObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasManualObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasManualObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasManualObject((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyManualObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyManualObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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 *","destroyManualObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ManualObject * >(argp2);
  (arg1)->destroyManualObject(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyManualObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyManualObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyManualObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyManualObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyManualObject((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyManualObject(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ManualObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyManualObject__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyManualObject__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyManualObject", 
    "    void SceneManager.destroyManualObject(Ogre::ManualObject *obj)\n"
    "    void SceneManager.destroyManualObject(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllManualObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllManualObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllManualObjects();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createBillboardChain__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BillboardChain *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createBillboardChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createBillboardChain", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBillboardChain", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BillboardChain *)(arg1)->createBillboardChain((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardChain, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createBillboardChain__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardChain *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createBillboardChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::BillboardChain *)(arg1)->createBillboardChain();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createBillboardChain(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createBillboardChain__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createBillboardChain__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.createBillboardChain", 
    "    Ogre::BillboardChain * SceneManager.createBillboardChain(Ogre::String const &name)\n"
    "    Ogre::BillboardChain * SceneManager.createBillboardChain()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getBillboardChain(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BillboardChain *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getBillboardChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getBillboardChain", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getBillboardChain", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BillboardChain *)((Ogre::SceneManager const *)arg1)->getBillboardChain((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardChain, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasBillboardChain(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasBillboardChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasBillboardChain", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasBillboardChain", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasBillboardChain((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyBillboardChain__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::BillboardChain *arg2 = (Ogre::BillboardChain *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyBillboardChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__BillboardChain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::BillboardChain *","destroyBillboardChain", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::BillboardChain * >(argp2);
  (arg1)->destroyBillboardChain(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyBillboardChain__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyBillboardChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyBillboardChain", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyBillboardChain", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyBillboardChain((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyBillboardChain(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__BillboardChain, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyBillboardChain__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyBillboardChain__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyBillboardChain", 
    "    void SceneManager.destroyBillboardChain(Ogre::BillboardChain *obj)\n"
    "    void SceneManager.destroyBillboardChain(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllBillboardChains(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllBillboardChains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllBillboardChains();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createRibbonTrail__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RibbonTrail *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createRibbonTrail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createRibbonTrail", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createRibbonTrail", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RibbonTrail *)(arg1)->createRibbonTrail((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createRibbonTrail__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RibbonTrail *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createRibbonTrail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::RibbonTrail *)(arg1)->createRibbonTrail();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createRibbonTrail(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createRibbonTrail__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createRibbonTrail__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.createRibbonTrail", 
    "    Ogre::RibbonTrail * SceneManager.createRibbonTrail(Ogre::String const &name)\n"
    "    Ogre::RibbonTrail * SceneManager.createRibbonTrail()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getRibbonTrail(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RibbonTrail *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getRibbonTrail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getRibbonTrail", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getRibbonTrail", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RibbonTrail *)((Ogre::SceneManager const *)arg1)->getRibbonTrail((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasRibbonTrail(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasRibbonTrail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasRibbonTrail", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasRibbonTrail", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasRibbonTrail((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyRibbonTrail__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RibbonTrail *arg2 = (Ogre::RibbonTrail *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyRibbonTrail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RibbonTrail, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RibbonTrail *","destroyRibbonTrail", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RibbonTrail * >(argp2);
  (arg1)->destroyRibbonTrail(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyRibbonTrail__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyRibbonTrail", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyRibbonTrail", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyRibbonTrail", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyRibbonTrail((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyRibbonTrail(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RibbonTrail, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyRibbonTrail__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyRibbonTrail__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyRibbonTrail", 
    "    void SceneManager.destroyRibbonTrail(Ogre::RibbonTrail *obj)\n"
    "    void SceneManager.destroyRibbonTrail(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllRibbonTrails(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllRibbonTrails", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllRibbonTrails();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createParticleSystem__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createParticleSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createParticleSystem", 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 &","createParticleSystem", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createParticleSystem", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  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_SceneManager_createParticleSystem__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createParticleSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createParticleSystem", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createParticleSystem", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createParticleSystem", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createParticleSystem", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createParticleSystem__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createParticleSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createParticleSystem", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","createParticleSystem", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createParticleSystem__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createParticleSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createParticleSystem", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createParticleSystem__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createParticleSystem", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  {
    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 &","createParticleSystem", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createParticleSystem", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createParticleSystem__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","createParticleSystem", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createParticleSystem__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ParticleSystem *)(arg1)->createParticleSystem();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createParticleSystem(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createParticleSystem__SWIG_6(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneManager_createParticleSystem__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createParticleSystem__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneManager_createParticleSystem__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_createParticleSystem__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createParticleSystem__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager_createParticleSystem__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.createParticleSystem", 
    "    Ogre::ParticleSystem * SceneManager.createParticleSystem(Ogre::String const &name, Ogre::String const &templateName)\n"
    "    Ogre::ParticleSystem * SceneManager.createParticleSystem(Ogre::String const &name, size_t quota, Ogre::String const &resourceGroup)\n"
    "    Ogre::ParticleSystem * SceneManager.createParticleSystem(Ogre::String const &name, size_t quota)\n"
    "    Ogre::ParticleSystem * SceneManager.createParticleSystem(Ogre::String const &name)\n"
    "    Ogre::ParticleSystem * SceneManager.createParticleSystem(size_t quota, Ogre::String const &resourceGroup)\n"
    "    Ogre::ParticleSystem * SceneManager.createParticleSystem(size_t quota)\n"
    "    Ogre::ParticleSystem * SceneManager.createParticleSystem()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getParticleSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::ParticleSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getParticleSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getParticleSystem", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ParticleSystem *)((Ogre::SceneManager const *)arg1)->getParticleSystem((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasParticleSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasParticleSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasParticleSystem", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasParticleSystem((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyParticleSystem__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::ParticleSystem *arg2 = (Ogre::ParticleSystem *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ParticleSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ParticleSystem *","destroyParticleSystem", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ParticleSystem * >(argp2);
  (arg1)->destroyParticleSystem(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyParticleSystem__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyParticleSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyParticleSystem", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyParticleSystem", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyParticleSystem((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyParticleSystem(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__ParticleSystem, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyParticleSystem__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyParticleSystem__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyParticleSystem", 
    "    void SceneManager.destroyParticleSystem(Ogre::ParticleSystem *obj)\n"
    "    void SceneManager.destroyParticleSystem(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllParticleSystems(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllParticleSystems", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllParticleSystems();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_clearScene(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","clearScene", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->clearScene();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setAmbientLight(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::ColourValue *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setAmbientLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setAmbientLight", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setAmbientLight", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setAmbientLight((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getAmbientLight(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getAmbientLight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::SceneManager const *)arg1)->getAmbientLight();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepareWorldGeometry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","prepareWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","prepareWorldGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepareWorldGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->prepareWorldGeometry((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepareWorldGeometry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","prepareWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","prepareWorldGeometry", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","prepareWorldGeometry", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","prepareWorldGeometry", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepareWorldGeometry", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->prepareWorldGeometry(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_prepareWorldGeometry__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","prepareWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","prepareWorldGeometry", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","prepareWorldGeometry", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->prepareWorldGeometry(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_prepareWorldGeometry(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_prepareWorldGeometry__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_prepareWorldGeometry__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_SceneManager_prepareWorldGeometry__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.prepareWorldGeometry", 
    "    void SceneManager.prepareWorldGeometry(Ogre::String const &filename)\n"
    "    void SceneManager.prepareWorldGeometry(Ogre::DataStreamPtr &stream, Ogre::String const &typeName)\n"
    "    void SceneManager.prepareWorldGeometry(Ogre::DataStreamPtr &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setWorldGeometry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","setWorldGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setWorldGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setWorldGeometry((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setWorldGeometry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","setWorldGeometry", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","setWorldGeometry", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","setWorldGeometry", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setWorldGeometry", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setWorldGeometry(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setWorldGeometry__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","setWorldGeometry", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","setWorldGeometry", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->setWorldGeometry(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_setWorldGeometry(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_setWorldGeometry__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_setWorldGeometry__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_SceneManager_setWorldGeometry__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.setWorldGeometry", 
    "    void SceneManager.setWorldGeometry(Ogre::String const &filename)\n"
    "    void SceneManager.setWorldGeometry(Ogre::DataStreamPtr &stream, Ogre::String const &typeName)\n"
    "    void SceneManager.setWorldGeometry(Ogre::DataStreamPtr &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_estimateWorldGeometry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  size_t 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","estimateWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","estimateWorldGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","estimateWorldGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->estimateWorldGeometry((Ogre::String const &)*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_estimateWorldGeometry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  size_t 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","estimateWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","estimateWorldGeometry", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","estimateWorldGeometry", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","estimateWorldGeometry", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","estimateWorldGeometry", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->estimateWorldGeometry(*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_estimateWorldGeometry__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","estimateWorldGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","estimateWorldGeometry", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","estimateWorldGeometry", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = (arg1)->estimateWorldGeometry(*arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_estimateWorldGeometry(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_estimateWorldGeometry__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_estimateWorldGeometry__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_SceneManager_estimateWorldGeometry__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.estimateWorldGeometry", 
    "    size_t SceneManager.estimateWorldGeometry(Ogre::String const &filename)\n"
    "    size_t SceneManager.estimateWorldGeometry(Ogre::DataStreamPtr &stream, Ogre::String const &typeName)\n"
    "    size_t SceneManager.estimateWorldGeometry(Ogre::DataStreamPtr &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSuggestedViewpoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::ViewPoint 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getSuggestedViewpoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","getSuggestedViewpoint", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->getSuggestedViewpoint(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ViewPoint(static_cast< const Ogre::ViewPoint& >(result))), SWIGTYPE_p_Ogre__ViewPoint, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSuggestedViewpoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ViewPoint 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getSuggestedViewpoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (arg1)->getSuggestedViewpoint();
  vresult = SWIG_NewPointerObj((new Ogre::ViewPoint(static_cast< const Ogre::ViewPoint& >(result))), SWIGTYPE_p_Ogre__ViewPoint, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_getSuggestedViewpoint(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_getSuggestedViewpoint__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneManager_getSuggestedViewpoint__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.getSuggestedViewpoint", 
    "    Ogre::ViewPoint SceneManager.getSuggestedViewpoint(bool random)\n"
    "    Ogre::ViewPoint SceneManager.getSuggestedViewpoint()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setOption(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setOption", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","setOption", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setOption", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void const *","setOption", 3, argv[1] )); 
  }
  result = (bool)(arg1)->setOption((Ogre::String const &)*arg2,(void const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getOption(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *arg3 = (void *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getOption", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getOption", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getOption", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1],SWIG_as_voidptrptr(&arg3), 0, 0);
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "void *","getOption", 3, argv[1] )); 
  }
  result = (bool)(arg1)->getOption((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasOption(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasOption", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasOption", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasOption", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasOption((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getOptionValues(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::StringVector *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getOptionValues", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getOptionValues", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getOptionValues", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::StringVector &","getOptionValues", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StringVector &","getOptionValues", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::StringVector * >(argp3);
  result = (bool)(arg1)->getOptionValues((Ogre::String const &)*arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getOptionKeys(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::StringVector *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getOptionKeys", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StringVector &","getOptionKeys", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StringVector &","getOptionKeys", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StringVector * >(argp2);
  result = (bool)(arg1)->getOptionKeys(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__updateSceneGraph(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_updateSceneGraph", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_updateSceneGraph", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_updateSceneGraph(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__findVisibleObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::VisibleObjectsBoundsInfo *arg3 = (Ogre::VisibleObjectsBoundsInfo *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_findVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_findVisibleObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::VisibleObjectsBoundsInfo *","_findVisibleObjects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::VisibleObjectsBoundsInfo * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_findVisibleObjects", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_findVisibleObjects(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__applySceneAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_applySceneAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->_applySceneAnimations();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__renderVisibleObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_renderVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->_renderVisibleObjects();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__renderScene(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg3 = (Ogre::Viewport *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_renderScene", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_renderScene", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Viewport *","_renderScene", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Viewport * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_renderScene", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_renderScene(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__queueSkiesForRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_queueSkiesForRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","_queueSkiesForRendering", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->_queueSkiesForRendering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setDestinationRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderSystem *arg2 = (Ogre::RenderSystem *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setDestinationRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","_setDestinationRenderSystem", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystem * >(argp2);
  (arg1)->_setDestinationRenderSystem(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Real arg8 ;
  int arg9 ;
  int arg10 ;
  Ogre::String *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int res11 = SWIG_OLDOBJ ;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","setSkyPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","setSkyPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  {
    std::string *ptr = (std::string *)0;
    res11 = SWIG_AsPtr_std_string(argv[9], &ptr);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 11, argv[9] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 11, argv[9])); 
    }
    arg11 = ptr;
  }
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,(Ogre::String const &)*arg11);
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Real arg8 ;
  int arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","setSkyPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","setSkyPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Real arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","setSkyPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlane__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_setSkyPlane(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[12];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 12) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager_setSkyPlane__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SceneManager_setSkyPlane__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager_setSkyPlane__SWIG_5(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager_setSkyPlane__SWIG_4(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SceneManager_setSkyPlane__SWIG_3(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SceneManager_setSkyPlane__SWIG_2(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SceneManager_setSkyPlane__SWIG_1(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_SceneManager_setSkyPlane__SWIG_0(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 12, "SceneManager.setSkyPlane", 
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, bool drawFirst, Ogre::Real bow, int xsegments, int ysegments, Ogre::String const &groupName)\n"
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, bool drawFirst, Ogre::Real bow, int xsegments, int ysegments)\n"
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, bool drawFirst, Ogre::Real bow, int xsegments)\n"
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, bool drawFirst, Ogre::Real bow)\n"
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, bool drawFirst)\n"
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling)\n"
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale)\n"
    "    void SceneManager.setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Real arg8 ;
  int arg9 ;
  int arg10 ;
  Ogre::String *arg11 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int res11 = SWIG_OLDOBJ ;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","_setSkyPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","_setSkyPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  {
    std::string *ptr = (std::string *)0;
    res11 = SWIG_AsPtr_std_string(argv[9], &ptr);
    if (!SWIG_IsOK(res11)) {
      SWIG_exception_fail(SWIG_ArgError(res11), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 11, argv[9] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 11, argv[9])); 
    }
    arg11 = ptr;
  }
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10,(Ogre::String const &)*arg11);
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  if (SWIG_IsNewObj(res11)) delete arg11;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Real arg8 ;
  int arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","_setSkyPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","_setSkyPlane", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9,arg10);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Real arg8 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","_setSkyPlane", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8,arg9);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Real arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  float val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  ecode8 = SWIG_AsVal_float(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::Real >(val8);
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyPlane", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyPlane", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4,arg5);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyPlane__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::Plane *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Plane,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Plane const &","_setSkyPlane", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Plane const &","_setSkyPlane", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Plane * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyPlane", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyPlane", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->_setSkyPlane(arg2,(Ogre::Plane const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__setSkyPlane(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[12];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 12) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager__setSkyPlane__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SceneManager__setSkyPlane__SWIG_6(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager__setSkyPlane__SWIG_5(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager__setSkyPlane__SWIG_4(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SceneManager__setSkyPlane__SWIG_3(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SceneManager__setSkyPlane__SWIG_2(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SceneManager__setSkyPlane__SWIG_1(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_float(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_float(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        int res = SWIG_AsPtr_std_string(argv[10], (std::string**)(0));
                        _v = SWIG_CheckState(res);
                        if (_v) {
                          return _wrap_SceneManager__setSkyPlane__SWIG_0(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 12, "SceneManager._setSkyPlane", 
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, Ogre::uint8 renderQueue, Ogre::Real bow, int xsegments, int ysegments, Ogre::String const &groupName)\n"
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, Ogre::uint8 renderQueue, Ogre::Real bow, int xsegments, int ysegments)\n"
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, Ogre::uint8 renderQueue, Ogre::Real bow, int xsegments)\n"
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, Ogre::uint8 renderQueue, Ogre::Real bow)\n"
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling, Ogre::uint8 renderQueue)\n"
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale, Ogre::Real tiling)\n"
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName, Ogre::Real scale)\n"
    "    void SceneManager._setSkyPlane(bool enable, Ogre::Plane const &plane, Ogre::String const &materialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyPlaneEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyPlaneEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyPlaneEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSkyPlaneEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isSkyPlaneEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isSkyPlaneEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isSkyPlaneEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSkyPlaneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getSkyPlaneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSkyPlaneNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSkyPlaneGenParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager::SkyPlaneGenParameters *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getSkyPlaneGenParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneManager::SkyPlaneGenParameters *) &((Ogre::SceneManager const *)arg1)->getSkyPlaneGenParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SkyPlaneGenParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  bool arg5 ;
  Ogre::Quaternion *arg6 = 0 ;
  Ogre::String *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","setSkyBox", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setSkyBox", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setSkyBox", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Quaternion * >(argp6);
  {
    std::string *ptr = (std::string *)0;
    res7 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyBox", 7, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyBox", 7, argv[5])); 
    }
    arg7 = ptr;
  }
  (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6,(Ogre::String const &)*arg7);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  bool arg5 ;
  Ogre::Quaternion *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","setSkyBox", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setSkyBox", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setSkyBox", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Quaternion * >(argp6);
  (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyBox__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","setSkyBox", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyBox__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyBox__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setSkyBox(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_setSkyBox(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _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_SceneManager_setSkyBox__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneManager_setSkyBox__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(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_SceneManager_setSkyBox__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SceneManager_setSkyBox__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SceneManager_setSkyBox__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneManager.setSkyBox", 
    "    void SceneManager.setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation, Ogre::String const &groupName)\n"
    "    void SceneManager.setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation)\n"
    "    void SceneManager.setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance, bool drawFirst)\n"
    "    void SceneManager.setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance)\n"
    "    void SceneManager.setSkyBox(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::uint8 arg5 ;
  Ogre::Quaternion *arg6 = 0 ;
  Ogre::String *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  int res7 = SWIG_OLDOBJ ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyBox", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint8 >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","_setSkyBox", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setSkyBox", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Quaternion * >(argp6);
  {
    std::string *ptr = (std::string *)0;
    res7 = SWIG_AsPtr_std_string(argv[5], &ptr);
    if (!SWIG_IsOK(res7)) {
      SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyBox", 7, argv[5] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyBox", 7, argv[5])); 
    }
    arg7 = ptr;
  }
  (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6,(Ogre::String const &)*arg7);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res7)) delete arg7;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::uint8 arg5 ;
  Ogre::Quaternion *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyBox", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint8 >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","_setSkyBox", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setSkyBox", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Quaternion * >(argp6);
  (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5,(Ogre::Quaternion const &)*arg6);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyBox__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::uint8 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  unsigned char val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_char(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyBox", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint8 >(val5);
  (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4,arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyBox__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyBox", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyBox__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyBox", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyBox", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyBox", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->_setSkyBox(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__setSkyBox(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _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_SceneManager__setSkyBox__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneManager__setSkyBox__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SceneManager__setSkyBox__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SceneManager__setSkyBox__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_unsigned_SS_char(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                int res = SWIG_AsPtr_std_string(argv[6], (std::string**)(0));
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SceneManager__setSkyBox__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneManager._setSkyBox", 
    "    void SceneManager._setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation, Ogre::String const &groupName)\n"
    "    void SceneManager._setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation)\n"
    "    void SceneManager._setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance, Ogre::uint8 renderQueue)\n"
    "    void SceneManager._setSkyBox(bool enable, Ogre::String const &materialName, Ogre::Real distance)\n"
    "    void SceneManager._setSkyBox(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyBoxEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyBoxEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyBoxEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSkyBoxEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isSkyBoxEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isSkyBoxEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isSkyBoxEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSkyBoxNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getSkyBoxNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSkyBoxNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSkyBoxGenParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager::SkyBoxGenParameters *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getSkyBoxGenParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneManager::SkyBoxGenParameters *) &((Ogre::SceneManager const *)arg1)->getSkyBoxGenParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SkyBoxGenParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  Ogre::String *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","setSkyDome", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","setSkyDome", 11, argv[9] ));
  } 
  arg11 = static_cast< int >(val11);
  {
    std::string *ptr = (std::string *)0;
    res12 = SWIG_AsPtr_std_string(argv[10], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "Ogre::String const &","setSkyDome", 12, argv[10] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 12, argv[10])); 
    }
    arg12 = ptr;
  }
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11,(Ogre::String const &)*arg12);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","setSkyDome", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","setSkyDome", 11, argv[9] ));
  } 
  arg11 = static_cast< int >(val11);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","setSkyDome", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 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","setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setSkyDome", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDome__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setSkyDome(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_setSkyDome(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[13];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 13) 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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _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_SceneManager_setSkyDome__SWIG_9(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneManager_setSkyDome__SWIG_8(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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_SceneManager_setSkyDome__SWIG_7(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager_setSkyDome__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager_setSkyDome__SWIG_5(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SceneManager_setSkyDome__SWIG_4(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SceneManager_setSkyDome__SWIG_3(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SceneManager_setSkyDome__SWIG_2(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_SceneManager_setSkyDome__SWIG_1(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_SceneManager_setSkyDome__SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "SceneManager.setSkyDome", 
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation, int xsegments, int ysegments, int ysegments_keep, Ogre::String const &groupName)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation, int xsegments, int ysegments, int ysegments_keep)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation, int xsegments, int ysegments)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation, int xsegments)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst, Ogre::Quaternion const &orientation)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, bool drawFirst)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature)\n"
    "    void SceneManager.setSkyDome(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  Ogre::String *arg12 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  int res12 = SWIG_OLDOBJ ;
  
  if ((argc < 11) || (argc > 11)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 11)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","_setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","_setSkyDome", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","_setSkyDome", 11, argv[9] ));
  } 
  arg11 = static_cast< int >(val11);
  {
    std::string *ptr = (std::string *)0;
    res12 = SWIG_AsPtr_std_string(argv[10], &ptr);
    if (!SWIG_IsOK(res12)) {
      SWIG_exception_fail(SWIG_ArgError(res12), Ruby_Format_TypeError( "", "Ogre::String const &","_setSkyDome", 12, argv[10] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 12, argv[10])); 
    }
    arg12 = ptr;
  }
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11,(Ogre::String const &)*arg12);
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res12)) delete arg12;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  int arg10 ;
  int arg11 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  int val11 ;
  int ecode11 = 0 ;
  
  if ((argc < 10) || (argc > 10)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 10)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","_setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","_setSkyDome", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  ecode11 = SWIG_AsVal_int(argv[9], &val11);
  if (!SWIG_IsOK(ecode11)) {
    SWIG_exception_fail(SWIG_ArgError(ecode11), Ruby_Format_TypeError( "", "int","_setSkyDome", 11, argv[9] ));
  } 
  arg11 = static_cast< int >(val11);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10,arg11);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  int arg10 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int val10 ;
  int ecode10 = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","_setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  ecode10 = SWIG_AsVal_int(argv[8], &val10);
  if (!SWIG_IsOK(ecode10)) {
    SWIG_exception_fail(SWIG_ArgError(ecode10), Ruby_Format_TypeError( "", "int","_setSkyDome", 10, argv[8] ));
  } 
  arg10 = static_cast< int >(val10);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9,arg10);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  int arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "int","_setSkyDome", 9, argv[7] ));
  } 
  arg9 = static_cast< int >(val9);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8,arg9);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  Ogre::Quaternion *arg8 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  void *argp8 ;
  int res8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  res8 = SWIG_ConvertPtr(argv[6], &argp8, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res8)) {
    SWIG_exception_fail(SWIG_ArgError(res8), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6] )); 
  }
  if (!argp8) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","_setSkyDome", 8, argv[6])); 
  }
  arg8 = reinterpret_cast< Ogre::Quaternion * >(argp8);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7,(Ogre::Quaternion const &)*arg8);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  Ogre::uint8 arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  unsigned char val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_char(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint8","_setSkyDome", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint8 >(val7);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6,arg7);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5,arg6);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 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","_setSkyDome", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4,arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","_setSkyDome", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setSkyDome__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setSkyDome", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setSkyDome", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","_setSkyDome", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_setSkyDome", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->_setSkyDome(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__setSkyDome(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[13];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 13) 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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _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_SceneManager__setSkyDome__SWIG_9(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneManager__setSkyDome__SWIG_8(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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_SceneManager__setSkyDome__SWIG_7(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager__setSkyDome__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager__setSkyDome__SWIG_5(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    return _wrap_SceneManager__setSkyDome__SWIG_4(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SceneManager__setSkyDome__SWIG_3(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        return _wrap_SceneManager__setSkyDome__SWIG_2(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 11) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          return _wrap_SceneManager__setSkyDome__SWIG_1(nargs, args, self);
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 12) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_char(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  void *vptr = 0;
                  int res = SWIG_ConvertPtr(argv[7], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
                  _v = SWIG_CheckState(res);
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      {
                        int res = SWIG_AsVal_int(argv[9], NULL);
                        _v = SWIG_CheckState(res);
                      }
                      if (_v) {
                        {
                          int res = SWIG_AsVal_int(argv[10], NULL);
                          _v = SWIG_CheckState(res);
                        }
                        if (_v) {
                          int res = SWIG_AsPtr_std_string(argv[11], (std::string**)(0));
                          _v = SWIG_CheckState(res);
                          if (_v) {
                            return _wrap_SceneManager__setSkyDome__SWIG_0(nargs, args, self);
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 13, "SceneManager._setSkyDome", 
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation, int xsegments, int ysegments, int ysegments_keep, Ogre::String const &groupName)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation, int xsegments, int ysegments, int ysegments_keep)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation, int xsegments, int ysegments)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation, int xsegments)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, Ogre::uint8 renderQueue, Ogre::Quaternion const &orientation)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance, Ogre::uint8 renderQueue)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling, Ogre::Real distance)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature, Ogre::Real tiling)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName, Ogre::Real curvature)\n"
    "    void SceneManager._setSkyDome(bool enable, Ogre::String const &materialName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSkyDomeEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSkyDomeEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSkyDomeEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSkyDomeEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isSkyDomeEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isSkyDomeEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isSkyDomeEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSkyDomeNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getSkyDomeNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneNode *)((Ogre::SceneManager const *)arg1)->getSkyDomeNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSkyDomeGenParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager::SkyDomeGenParameters *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getSkyDomeGenParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneManager::SkyDomeGenParameters *) &((Ogre::SceneManager const *)arg1)->getSkyDomeGenParameters();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SkyDomeGenParameters, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFog__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Real arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  float val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 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","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_float(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::Real >(val6);
  (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFog__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 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","setFog", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFog__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","setFog", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFog__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::FogMode arg2 ;
  Ogre::ColourValue *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setFog", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setFog", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ColourValue * >(argp3);
  (arg1)->setFog(arg2,(Ogre::ColourValue const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFog__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::FogMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FogMode","setFog", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FogMode >(val2);
  (arg1)->setFog(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFog__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->setFog();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_setFog(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_setFog__SWIG_5(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneManager_setFog__SWIG_4(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneManager_setFog__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneManager_setFog__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _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_SceneManager_setFog__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__ColourValue, 0);
        _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) {
              {
                int res = SWIG_AsVal_float(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager_setFog__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneManager.setFog", 
    "    void SceneManager.setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart, Ogre::Real linearEnd)\n"
    "    void SceneManager.setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity, Ogre::Real linearStart)\n"
    "    void SceneManager.setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour, Ogre::Real expDensity)\n"
    "    void SceneManager.setFog(Ogre::FogMode mode, Ogre::ColourValue const &colour)\n"
    "    void SceneManager.setFog(Ogre::FogMode mode)\n"
    "    void SceneManager.setFog()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getFogMode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::FogMode 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getFogMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::FogMode)((Ogre::SceneManager const *)arg1)->getFogMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getFogColour(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getFogColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::SceneManager const *)arg1)->getFogColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getFogStart(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getFogStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getFogStart();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getFogEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getFogEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getFogEnd();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getFogDensity(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getFogDensity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getFogDensity();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createBillboardSet__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  Ogre::BillboardSet *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createBillboardSet", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBillboardSet", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","createBillboardSet", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(val3);
  result = (Ogre::BillboardSet *)(arg1)->createBillboardSet((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createBillboardSet__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BillboardSet *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createBillboardSet", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createBillboardSet", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BillboardSet *)(arg1)->createBillboardSet((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createBillboardSet__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::BillboardSet *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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","createBillboardSet", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  result = (Ogre::BillboardSet *)(arg1)->createBillboardSet(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createBillboardSet__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::BillboardSet *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::BillboardSet *)(arg1)->createBillboardSet();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createBillboardSet(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createBillboardSet__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneManager_createBillboardSet__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createBillboardSet__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_AsVal_unsigned_SS_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_createBillboardSet__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.createBillboardSet", 
    "    Ogre::BillboardSet * SceneManager.createBillboardSet(Ogre::String const &name, unsigned int poolSize)\n"
    "    Ogre::BillboardSet * SceneManager.createBillboardSet(Ogre::String const &name)\n"
    "    Ogre::BillboardSet * SceneManager.createBillboardSet(unsigned int poolSize)\n"
    "    Ogre::BillboardSet * SceneManager.createBillboardSet()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getBillboardSet(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::BillboardSet *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getBillboardSet", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getBillboardSet", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::BillboardSet *)((Ogre::SceneManager const *)arg1)->getBillboardSet((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasBillboardSet(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasBillboardSet", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasBillboardSet", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasBillboardSet((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyBillboardSet__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::BillboardSet *arg2 = (Ogre::BillboardSet *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__BillboardSet, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::BillboardSet *","destroyBillboardSet", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::BillboardSet * >(argp2);
  (arg1)->destroyBillboardSet(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyBillboardSet__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyBillboardSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyBillboardSet", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyBillboardSet", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyBillboardSet((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyBillboardSet(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__BillboardSet, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyBillboardSet__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyBillboardSet__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyBillboardSet", 
    "    void SceneManager.destroyBillboardSet(Ogre::BillboardSet *set)\n"
    "    void SceneManager.destroyBillboardSet(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllBillboardSets(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllBillboardSets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllBillboardSets();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setDisplaySceneNodes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setDisplaySceneNodes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setDisplaySceneNodes", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setDisplaySceneNodes(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getDisplaySceneNodes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getDisplaySceneNodes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getDisplaySceneNodes();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Animation *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","createAnimation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Animation *)(arg1)->createAnimation((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Animation *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Animation *)((Ogre::SceneManager const *)arg1)->getAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Animation, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasAnimation((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyAnimation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAnimation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyAnimation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllAnimations(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllAnimations", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllAnimations();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::AnimationState *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::AnimationState *)(arg1)->createAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::AnimationState *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::AnimationState *)((Ogre::SceneManager const *)arg1)->getAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AnimationState, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasAnimationState((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAnimationState(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAnimationState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyAnimationState", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAnimationState", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyAnimationState((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllAnimationStates(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllAnimationStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllAnimationStates();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manualRender__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderOperation *arg2 = (Ogre::RenderOperation *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Matrix4 *arg5 = 0 ;
  Ogre::Matrix4 *arg6 = 0 ;
  Ogre::Matrix4 *arg7 = 0 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","manualRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","manualRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass *","manualRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","manualRender", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Matrix4 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 7, argv[5] )); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 7, argv[5])); 
  }
  arg7 = reinterpret_cast< Ogre::Matrix4 * >(argp7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","manualRender", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  (arg1)->manualRender(arg2,arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,(Ogre::Matrix4 const &)*arg7,arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manualRender__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderOperation *arg2 = (Ogre::RenderOperation *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Matrix4 *arg5 = 0 ;
  Ogre::Matrix4 *arg6 = 0 ;
  Ogre::Matrix4 *arg7 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  void *argp7 ;
  int res7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","manualRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderOperation, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation *","manualRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass *","manualRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","manualRender", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Matrix4 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  res7 = SWIG_ConvertPtr(argv[5], &argp7, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res7)) {
    SWIG_exception_fail(SWIG_ArgError(res7), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 7, argv[5] )); 
  }
  if (!argp7) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 7, argv[5])); 
  }
  arg7 = reinterpret_cast< Ogre::Matrix4 * >(argp7);
  (arg1)->manualRender(arg2,arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,(Ogre::Matrix4 const &)*arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manualRender__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Matrix4 *arg5 = 0 ;
  Ogre::Matrix4 *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  bool arg9 ;
  Ogre::LightList *arg10 = (Ogre::LightList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  void *argp10 = 0 ;
  int res10 = 0 ;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","manualRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","manualRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass const *","manualRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","manualRender", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Matrix4 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","manualRender", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","manualRender", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","manualRender", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  res10 = SWIG_ConvertPtr(argv[8], &argp10,SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  if (!SWIG_IsOK(res10)) {
    SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "Ogre::LightList const *","manualRender", 10, argv[8] )); 
  }
  arg10 = reinterpret_cast< Ogre::LightList * >(argp10);
  (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7,arg8,arg9,(Ogre::LightList const *)arg10);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manualRender__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Matrix4 *arg5 = 0 ;
  Ogre::Matrix4 *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  bool arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  bool val9 ;
  int ecode9 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","manualRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","manualRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass const *","manualRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","manualRender", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Matrix4 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","manualRender", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","manualRender", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  ecode9 = SWIG_AsVal_bool(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "bool","manualRender", 9, argv[7] ));
  } 
  arg9 = static_cast< bool >(val9);
  (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7,arg8,arg9);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manualRender__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Matrix4 *arg5 = 0 ;
  Ogre::Matrix4 *arg6 = 0 ;
  bool arg7 ;
  bool arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  bool val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","manualRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","manualRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass const *","manualRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","manualRender", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Matrix4 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","manualRender", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  ecode8 = SWIG_AsVal_bool(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "bool","manualRender", 8, argv[6] ));
  } 
  arg8 = static_cast< bool >(val8);
  (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7,arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manualRender__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Matrix4 *arg5 = 0 ;
  Ogre::Matrix4 *arg6 = 0 ;
  bool arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  bool val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","manualRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","manualRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass const *","manualRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","manualRender", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Matrix4 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  ecode7 = SWIG_AsVal_bool(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "bool","manualRender", 7, argv[5] ));
  } 
  arg7 = static_cast< bool >(val7);
  (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_manualRender__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Renderable *arg2 = (Ogre::Renderable *) 0 ;
  Ogre::Pass *arg3 = (Ogre::Pass *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Matrix4 *arg5 = 0 ;
  Ogre::Matrix4 *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  void *argp6 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","manualRender", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable *","manualRender", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Pass const *","manualRender", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Pass * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","manualRender", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Matrix4 * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__Matrix4,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Matrix4 const &","manualRender", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Matrix4 const &","manualRender", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Matrix4 * >(argp6);
  (arg1)->manualRender(arg2,(Ogre::Pass const *)arg3,arg4,(Ogre::Matrix4 const &)*arg5,(Ogre::Matrix4 const &)*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_manualRender(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[11];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 11) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SceneManager_manualRender__SWIG_6(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager_manualRender__SWIG_5(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderOperation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  return _wrap_SceneManager_manualRender__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderOperation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                void *vptr = 0;
                int res = SWIG_ConvertPtr(argv[6], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
                _v = SWIG_CheckState(res);
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SceneManager_manualRender__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SceneManager_manualRender__SWIG_4(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_SceneManager_manualRender__SWIG_3(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Viewport, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                {
                  int res = SWIG_AsVal_bool(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_bool(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_bool(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      void *vptr = 0;
                      int res = SWIG_ConvertPtr(argv[9], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_SceneManager_manualRender__SWIG_2(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "SceneManager.manualRender", 
    "    void SceneManager.manualRender(Ogre::RenderOperation *rend, Ogre::Pass *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &worldMatrix, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix, bool doBeginEndFrame)\n"
    "    void SceneManager.manualRender(Ogre::RenderOperation *rend, Ogre::Pass *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &worldMatrix, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix)\n"
    "    void SceneManager.manualRender(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix, bool doBeginEndFrame, bool lightScissoringClipping, bool doLightIteration, Ogre::LightList const *manualLightList)\n"
    "    void SceneManager.manualRender(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix, bool doBeginEndFrame, bool lightScissoringClipping, bool doLightIteration)\n"
    "    void SceneManager.manualRender(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix, bool doBeginEndFrame, bool lightScissoringClipping)\n"
    "    void SceneManager.manualRender(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix, bool doBeginEndFrame)\n"
    "    void SceneManager.manualRender(Ogre::Renderable *rend, Ogre::Pass const *pass, Ogre::Viewport *vp, Ogre::Matrix4 const &viewMatrix, Ogre::Matrix4 const &projMatrix)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderQueue *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::RenderQueue *)(arg1)->getRenderQueue();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_addRenderQueueListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderQueueListener *arg2 = (Ogre::RenderQueueListener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","addRenderQueueListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueueListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueueListener *","addRenderQueueListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueueListener * >(argp2);
  (arg1)->addRenderQueueListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_removeRenderQueueListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderQueueListener *arg2 = (Ogre::RenderQueueListener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","removeRenderQueueListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueueListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueueListener *","removeRenderQueueListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueueListener * >(argp2);
  (arg1)->removeRenderQueueListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_addRenderObjectListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderObjectListener *arg2 = (Ogre::RenderObjectListener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","addRenderObjectListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderObjectListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderObjectListener *","addRenderObjectListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderObjectListener * >(argp2);
  (arg1)->addRenderObjectListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_removeRenderObjectListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderObjectListener *arg2 = (Ogre::RenderObjectListener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","removeRenderObjectListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderObjectListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderObjectListener *","removeRenderObjectListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderObjectListener * >(argp2);
  (arg1)->removeRenderObjectListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_addSpecialCaseRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","addSpecialCaseRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","addSpecialCaseRenderQueue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->addSpecialCaseRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_removeSpecialCaseRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","removeSpecialCaseRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","removeSpecialCaseRenderQueue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->removeSpecialCaseRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_clearSpecialCaseRenderQueues(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","clearSpecialCaseRenderQueues", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->clearSpecialCaseRenderQueues();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setSpecialCaseRenderQueueMode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneManager::SpecialCaseRenderQueueMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSpecialCaseRenderQueueMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneManager::SpecialCaseRenderQueueMode","setSpecialCaseRenderQueueMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneManager::SpecialCaseRenderQueueMode >(val2);
  (arg1)->setSpecialCaseRenderQueueMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getSpecialCaseRenderQueueMode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager::SpecialCaseRenderQueueMode 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getSpecialCaseRenderQueueMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneManager::SpecialCaseRenderQueueMode)(arg1)->getSpecialCaseRenderQueueMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isRenderQueueToBeProcessed(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","isRenderQueueToBeProcessed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","isRenderQueueToBeProcessed", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (bool)(arg1)->isRenderQueueToBeProcessed(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setWorldGeometryRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setWorldGeometryRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setWorldGeometryRenderQueue", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setWorldGeometryRenderQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getWorldGeometryRenderQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getWorldGeometryRenderQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::uint8)(arg1)->getWorldGeometryRenderQueue();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_showBoundingBoxes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","showBoundingBoxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","showBoundingBoxes", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->showBoundingBoxes(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShowBoundingBoxes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShowBoundingBoxes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getShowBoundingBoxes();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__notifyAutotrackingSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_notifyAutotrackingSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode *","_notifyAutotrackingSceneNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_notifyAutotrackingSceneNode", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_notifyAutotrackingSceneNode(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createAABBQuery__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  Ogre::AxisAlignedBoxSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createAABBQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","createAABBQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","createAABBQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned long","createAABBQuery", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned long >(val3);
  result = (Ogre::AxisAlignedBoxSceneQuery *)(arg1)->createAABBQuery((Ogre::AxisAlignedBox const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBoxSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createAABBQuery__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::AxisAlignedBoxSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createAABBQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","createAABBQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","createAABBQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  result = (Ogre::AxisAlignedBoxSceneQuery *)(arg1)->createAABBQuery((Ogre::AxisAlignedBox const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBoxSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createAABBQuery(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_createAABBQuery__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_createAABBQuery__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.createAABBQuery", 
    "    Ogre::AxisAlignedBoxSceneQuery * SceneManager.createAABBQuery(Ogre::AxisAlignedBox const &box, unsigned long mask)\n"
    "    Ogre::AxisAlignedBoxSceneQuery * SceneManager.createAABBQuery(Ogre::AxisAlignedBox const &box)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createSphereQuery__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  Ogre::SphereSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSphereQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","createSphereQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","createSphereQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned long","createSphereQuery", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned long >(val3);
  result = (Ogre::SphereSceneQuery *)(arg1)->createSphereQuery((Ogre::Sphere const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SphereSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createSphereQuery__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::SphereSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSphereQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","createSphereQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","createSphereQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  result = (Ogre::SphereSceneQuery *)(arg1)->createSphereQuery((Ogre::Sphere const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SphereSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createSphereQuery(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_createSphereQuery__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_createSphereQuery__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.createSphereQuery", 
    "    Ogre::SphereSceneQuery * SceneManager.createSphereQuery(Ogre::Sphere const &sphere, unsigned long mask)\n"
    "    Ogre::SphereSceneQuery * SceneManager.createSphereQuery(Ogre::Sphere const &sphere)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createPlaneBoundedVolumeQuery__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::PlaneBoundedVolumeList *arg2 = 0 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  Ogre::PlaneBoundedVolumeListSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createPlaneBoundedVolumeQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolumeList const &","createPlaneBoundedVolumeQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PlaneBoundedVolumeList const &","createPlaneBoundedVolumeQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PlaneBoundedVolumeList * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned long","createPlaneBoundedVolumeQuery", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned long >(val3);
  result = (Ogre::PlaneBoundedVolumeListSceneQuery *)(arg1)->createPlaneBoundedVolumeQuery((Ogre::PlaneBoundedVolumeList const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PlaneBoundedVolumeListSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createPlaneBoundedVolumeQuery__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::PlaneBoundedVolumeList *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::PlaneBoundedVolumeListSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createPlaneBoundedVolumeQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PlaneBoundedVolumeList const &","createPlaneBoundedVolumeQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PlaneBoundedVolumeList const &","createPlaneBoundedVolumeQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PlaneBoundedVolumeList * >(argp2);
  result = (Ogre::PlaneBoundedVolumeListSceneQuery *)(arg1)->createPlaneBoundedVolumeQuery((Ogre::PlaneBoundedVolumeList const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PlaneBoundedVolumeListSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createPlaneBoundedVolumeQuery(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_createPlaneBoundedVolumeQuery__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__PlaneBoundedVolume_Ogre__STLAllocatorT_Ogre__PlaneBoundedVolume_Ogre__GeneralAllocPolicy_t_t__type, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_createPlaneBoundedVolumeQuery__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.createPlaneBoundedVolumeQuery", 
    "    Ogre::PlaneBoundedVolumeListSceneQuery * SceneManager.createPlaneBoundedVolumeQuery(Ogre::PlaneBoundedVolumeList const &volumes, unsigned long mask)\n"
    "    Ogre::PlaneBoundedVolumeListSceneQuery * SceneManager.createPlaneBoundedVolumeQuery(Ogre::PlaneBoundedVolumeList const &volumes)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createRayQuery__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  unsigned long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  unsigned long val3 ;
  int ecode3 = 0 ;
  Ogre::RaySceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createRayQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","createRayQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","createRayQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned long","createRayQuery", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned long >(val3);
  result = (Ogre::RaySceneQuery *)(arg1)->createRayQuery((Ogre::Ray const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RaySceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createRayQuery__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::RaySceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createRayQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","createRayQuery", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","createRayQuery", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  result = (Ogre::RaySceneQuery *)(arg1)->createRayQuery((Ogre::Ray const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RaySceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createRayQuery(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_createRayQuery__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_createRayQuery__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.createRayQuery", 
    "    Ogre::RaySceneQuery * SceneManager.createRayQuery(Ogre::Ray const &ray, unsigned long mask)\n"
    "    Ogre::RaySceneQuery * SceneManager.createRayQuery(Ogre::Ray const &ray)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createIntersectionQuery__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long val2 ;
  int ecode2 = 0 ;
  Ogre::IntersectionSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createIntersectionQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "unsigned long","createIntersectionQuery", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned long >(val2);
  result = (Ogre::IntersectionSceneQuery *)(arg1)->createIntersectionQuery(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IntersectionSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createIntersectionQuery__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IntersectionSceneQuery *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createIntersectionQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::IntersectionSceneQuery *)(arg1)->createIntersectionQuery();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IntersectionSceneQuery, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createIntersectionQuery(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_SceneManager_createIntersectionQuery__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneManager_createIntersectionQuery__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.createIntersectionQuery", 
    "    Ogre::IntersectionSceneQuery * SceneManager.createIntersectionQuery(unsigned long mask)\n"
    "    Ogre::IntersectionSceneQuery * SceneManager.createIntersectionQuery()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneQuery *arg2 = (Ogre::SceneQuery *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyQuery", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQuery *","destroyQuery", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQuery * >(argp2);
  (arg1)->destroyQuery(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getCameraIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SceneManager::CameraIterator > 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getCameraIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (arg1)->getCameraIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SceneManager::CameraIterator(static_cast< const Ogre::SceneManager::CameraIterator& >(result))), SWIGTYPE_p_Ogre__SceneManager__CameraIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getAnimationIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SceneManager::AnimationIterator > 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getAnimationIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (arg1)->getAnimationIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SceneManager::AnimationIterator(static_cast< const Ogre::SceneManager::AnimationIterator& >(result))), SWIGTYPE_p_Ogre__SceneManager__AnimationIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getAnimationStateIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::AnimationStateIterator > 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getAnimationStateIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (arg1)->getAnimationStateIterator();
  vresult = SWIG_NewPointerObj((new Ogre::AnimationStateIterator(static_cast< const Ogre::AnimationStateIterator& >(result))), SWIGTYPE_p_Ogre__AnimationStateIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::ShadowTechnique arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::ShadowTechnique","setShadowTechnique", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::ShadowTechnique >(val2);
  (arg1)->setShadowTechnique(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ShadowTechnique 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ShadowTechnique)((Ogre::SceneManager const *)arg1)->getShadowTechnique();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShowDebugShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShowDebugShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShowDebugShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShowDebugShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShowDebugShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShowDebugShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getShowDebugShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowColour(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::ColourValue *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setShadowColour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setShadowColour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setShadowColour((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowColour(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowColour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ColourValue *) &((Ogre::SceneManager const *)arg1)->getShadowColour();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowDirectionalLightExtrusionDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowDirectionalLightExtrusionDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowDirectionalLightExtrusionDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowDirectionalLightExtrusionDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowDirectionalLightExtrusionDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowDirectionalLightExtrusionDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowDirectionalLightExtrusionDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowFarDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowFarDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowFarDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowFarDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowFarDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowFarDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowFarDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowFarDistanceSquared(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowFarDistanceSquared", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowFarDistanceSquared();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowIndexBufferSize(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowIndexBufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setShadowIndexBufferSize", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setShadowIndexBufferSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowIndexBufferSize(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowIndexBufferSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = ((Ogre::SceneManager const *)arg1)->getShadowIndexBufferSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureSize(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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","setShadowTextureSize", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setShadowTextureSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureConfig__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  Ogre::PixelFormat arg5 ;
  unsigned short arg6 ;
  Ogre::uint16 arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureConfig", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setShadowTextureConfig", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setShadowTextureConfig", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 6, argv[4] ));
  } 
  arg6 = static_cast< unsigned short >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint16","setShadowTextureConfig", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint16 >(val7);
  (arg1)->setShadowTextureConfig(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureConfig__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  Ogre::PixelFormat arg5 ;
  unsigned short arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureConfig", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setShadowTextureConfig", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setShadowTextureConfig", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 6, argv[4] ));
  } 
  arg6 = static_cast< unsigned short >(val6);
  (arg1)->setShadowTextureConfig(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureConfig__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  Ogre::PixelFormat arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureConfig", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setShadowTextureConfig", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureConfig", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setShadowTextureConfig", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::PixelFormat >(val5);
  (arg1)->setShadowTextureConfig(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureConfig__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  Ogre::ShadowTextureConfig *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureConfig", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setShadowTextureConfig", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__ShadowTextureConfig,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ShadowTextureConfig const &","setShadowTextureConfig", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ShadowTextureConfig const &","setShadowTextureConfig", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::ShadowTextureConfig * >(argp3);
  (arg1)->setShadowTextureConfig(arg2,(Ogre::ShadowTextureConfig const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_setShadowTextureConfig(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[8];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 8) 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_Ogre__SceneManager, 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__ShadowTextureConfig, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneManager_setShadowTextureConfig__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(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_SceneManager_setShadowTextureConfig__SWIG_2(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(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_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager_setShadowTextureConfig__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(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_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager_setShadowTextureConfig__SWIG_0(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 8, "SceneManager.setShadowTextureConfig", 
    "    void SceneManager.setShadowTextureConfig(size_t shadowIndex, unsigned short width, unsigned short height, Ogre::PixelFormat format, unsigned short fsaa, Ogre::uint16 depthBufferPoolId)\n"
    "    void SceneManager.setShadowTextureConfig(size_t shadowIndex, unsigned short width, unsigned short height, Ogre::PixelFormat format, unsigned short fsaa)\n"
    "    void SceneManager.setShadowTextureConfig(size_t shadowIndex, unsigned short width, unsigned short height, Ogre::PixelFormat format)\n"
    "    void SceneManager.setShadowTextureConfig(size_t shadowIndex, Ogre::ShadowTextureConfig const &config)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowTextureConfigIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstShadowTextureConfigIterator > 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowTextureConfigIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = ((Ogre::SceneManager const *)arg1)->getShadowTextureConfigIterator();
  vresult = SWIG_NewPointerObj((new Ogre::ConstShadowTextureConfigIterator(static_cast< const Ogre::ConstShadowTextureConfigIterator& >(result))), SWIGTYPE_p_Ogre__ConstShadowTextureConfigIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTexturePixelFormat(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTexturePixelFormat", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setShadowTexturePixelFormat", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  (arg1)->setShadowTexturePixelFormat(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureFSAA(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureFSAA", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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","setShadowTextureFSAA", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  (arg1)->setShadowTextureFSAA(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setShadowTextureCount", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->setShadowTextureCount(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowTextureCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowTextureCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = ((Ogre::SceneManager const *)arg1)->getShadowTextureCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureCountPerLightType(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Light::LightTypes arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureCountPerLightType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Light::LightTypes","setShadowTextureCountPerLightType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Light::LightTypes >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setShadowTextureCountPerLightType", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->setShadowTextureCountPerLightType(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowTextureCountPerLightType(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Light::LightTypes arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  size_t 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowTextureCountPerLightType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Light::LightTypes","getShadowTextureCountPerLightType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Light::LightTypes >(val2);
  result = ((Ogre::SceneManager const *)arg1)->getShadowTextureCountPerLightType(arg2);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureSettings__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  Ogre::PixelFormat arg4 ;
  unsigned short arg5 ;
  Ogre::uint16 arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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","setShadowTextureSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setShadowTextureSettings", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureSettings", 5, argv[3] ));
  } 
  arg5 = static_cast< unsigned short >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint16","setShadowTextureSettings", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::uint16 >(val6);
  (arg1)->setShadowTextureSettings(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureSettings__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  Ogre::PixelFormat arg4 ;
  unsigned short arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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","setShadowTextureSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setShadowTextureSettings", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureSettings", 5, argv[3] ));
  } 
  arg5 = static_cast< unsigned short >(val5);
  (arg1)->setShadowTextureSettings(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureSettings__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  Ogre::PixelFormat arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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","setShadowTextureSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::PixelFormat","setShadowTextureSettings", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::PixelFormat >(val4);
  (arg1)->setShadowTextureSettings(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureSettings__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  unsigned short arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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","setShadowTextureSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","setShadowTextureSettings", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  (arg1)->setShadowTextureSettings(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_setShadowTextureSettings(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_setShadowTextureSettings__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(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_SceneManager_setShadowTextureSettings__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(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_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_SceneManager_setShadowTextureSettings__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(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_unsigned_SS_short(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_unsigned_SS_short(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager_setShadowTextureSettings__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneManager.setShadowTextureSettings", 
    "    void SceneManager.setShadowTextureSettings(unsigned short size, unsigned short count, Ogre::PixelFormat fmt, unsigned short fsaa, Ogre::uint16 depthBufferPoolId)\n"
    "    void SceneManager.setShadowTextureSettings(unsigned short size, unsigned short count, Ogre::PixelFormat fmt, unsigned short fsaa)\n"
    "    void SceneManager.setShadowTextureSettings(unsigned short size, unsigned short count, Ogre::PixelFormat fmt)\n"
    "    void SceneManager.setShadowTextureSettings(unsigned short size, unsigned short count)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::TexturePtr *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getShadowTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getShadowTexture", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::TexturePtr *) &(arg1)->getShadowTexture(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowDirLightTextureOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowDirLightTextureOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowDirLightTextureOffset", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowDirLightTextureOffset(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowDirLightTextureOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowDirLightTextureOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Real)((Ogre::SceneManager const *)arg1)->getShadowDirLightTextureOffset();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureFadeStart(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureFadeStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowTextureFadeStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowTextureFadeStart(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureFadeEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureFadeEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setShadowTextureFadeEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setShadowTextureFadeEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureSelfShadow(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureSelfShadow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowTextureSelfShadow", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowTextureSelfShadow(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowTextureSelfShadow(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowTextureSelfShadow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getShadowTextureSelfShadow();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureCasterMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureCasterMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","setShadowTextureCasterMaterial", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowTextureCasterMaterial", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowTextureCasterMaterial((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowTextureReceiverMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowTextureReceiverMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","setShadowTextureReceiverMaterial", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setShadowTextureReceiverMaterial", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setShadowTextureReceiverMaterial((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowCasterRenderBackFaces(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowCasterRenderBackFaces", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowCasterRenderBackFaces", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowCasterRenderBackFaces(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowCasterRenderBackFaces(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCasterRenderBackFaces", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getShadowCasterRenderBackFaces();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::ShadowCameraSetupPtr *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowCameraSetup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ShadowCameraSetupPtr const &","setShadowCameraSetup", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ShadowCameraSetupPtr const &","setShadowCameraSetup", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ShadowCameraSetupPtr * >(argp2);
  (arg1)->setShadowCameraSetup((Ogre::ShadowCameraSetupPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ShadowCameraSetupPtr *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCameraSetup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::ShadowCameraSetupPtr *) &((Ogre::SceneManager const *)arg1)->getShadowCameraSetup();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__ShadowCameraSetup_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowUseInfiniteFarPlane(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowUseInfiniteFarPlane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowUseInfiniteFarPlane", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowUseInfiniteFarPlane(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isShadowTechniqueStencilBased(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isShadowTechniqueStencilBased", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueStencilBased();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isShadowTechniqueTextureBased(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isShadowTechniqueTextureBased", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueTextureBased();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isShadowTechniqueModulative(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isShadowTechniqueModulative", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueModulative();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isShadowTechniqueAdditive(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isShadowTechniqueAdditive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueAdditive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isShadowTechniqueIntegrated(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isShadowTechniqueIntegrated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueIntegrated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isShadowTechniqueInUse(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isShadowTechniqueInUse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isShadowTechniqueInUse();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setShadowUseLightClipPlanes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setShadowUseLightClipPlanes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setShadowUseLightClipPlanes", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setShadowUseLightClipPlanes(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowUseLightClipPlanes(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowUseLightClipPlanes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getShadowUseLightClipPlanes();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setActiveCompositorChain(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::CompositorChain *arg2 = (Ogre::CompositorChain *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setActiveCompositorChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::CompositorChain *","_setActiveCompositorChain", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::CompositorChain * >(argp2);
  (arg1)->_setActiveCompositorChain(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setLateMaterialResolving(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setLateMaterialResolving", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setLateMaterialResolving", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setLateMaterialResolving(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_isLateMaterialResolving(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","isLateMaterialResolving", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->isLateMaterialResolving();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__getActiveCompositorChain(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::CompositorChain *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","_getActiveCompositorChain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::CompositorChain *)((Ogre::SceneManager const *)arg1)->_getActiveCompositorChain();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__CompositorChain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneManager::Listener *arg2 = (Ogre::SceneManager::Listener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneManager::Listener *arg2 = (Ogre::SceneManager::Listener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createStaticGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::StaticGeometry *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createStaticGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createStaticGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createStaticGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::StaticGeometry *)(arg1)->createStaticGeometry((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StaticGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getStaticGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::StaticGeometry *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getStaticGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getStaticGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getStaticGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::StaticGeometry *)((Ogre::SceneManager const *)arg1)->getStaticGeometry((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StaticGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasStaticGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasStaticGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasStaticGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasStaticGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasStaticGeometry((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyStaticGeometry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::StaticGeometry *arg2 = (Ogre::StaticGeometry *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyStaticGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","destroyStaticGeometry", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::StaticGeometry * >(argp2);
  (arg1)->destroyStaticGeometry(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyStaticGeometry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyStaticGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyStaticGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyStaticGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyStaticGeometry((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyStaticGeometry(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StaticGeometry, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyStaticGeometry__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyStaticGeometry__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyStaticGeometry", 
    "    void SceneManager.destroyStaticGeometry(Ogre::StaticGeometry *geom)\n"
    "    void SceneManager.destroyStaticGeometry(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllStaticGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllStaticGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllStaticGeometry();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createInstancedGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::InstancedGeometry *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstancedGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createInstancedGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstancedGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::InstancedGeometry *)(arg1)->createInstancedGeometry((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getInstancedGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::InstancedGeometry *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getInstancedGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getInstancedGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getInstancedGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::InstancedGeometry *)((Ogre::SceneManager const *)arg1)->getInstancedGeometry((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedGeometry, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyInstancedGeometry__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::InstancedGeometry *arg2 = (Ogre::InstancedGeometry *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyInstancedGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__InstancedGeometry, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstancedGeometry *","destroyInstancedGeometry", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::InstancedGeometry * >(argp2);
  (arg1)->destroyInstancedGeometry(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyInstancedGeometry__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyInstancedGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyInstancedGeometry", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyInstancedGeometry", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyInstancedGeometry((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyInstancedGeometry(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__InstancedGeometry, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyInstancedGeometry__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyInstancedGeometry__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyInstancedGeometry", 
    "    void SceneManager.destroyInstancedGeometry(Ogre::InstancedGeometry *geom)\n"
    "    void SceneManager.destroyInstancedGeometry(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllInstancedGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllInstancedGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllInstancedGeometry();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createInstanceManager__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  size_t arg6 ;
  Ogre::uint16 arg7 ;
  unsigned short arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  unsigned short val8 ;
  int ecode8 = 0 ;
  Ogre::InstanceManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createInstanceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 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 &","createInstanceManager", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createInstanceManager", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","createInstanceManager", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createInstanceManager", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint16","createInstanceManager", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint16 >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_short(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "unsigned short","createInstanceManager", 8, argv[6] ));
  } 
  arg8 = static_cast< unsigned short >(val8);
  result = (Ogre::InstanceManager *)(arg1)->createInstanceManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createInstanceManager__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  size_t arg6 ;
  Ogre::uint16 arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  Ogre::InstanceManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createInstanceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 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 &","createInstanceManager", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createInstanceManager", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","createInstanceManager", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createInstanceManager", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint16","createInstanceManager", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint16 >(val7);
  result = (Ogre::InstanceManager *)(arg1)->createInstanceManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createInstanceManager__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  Ogre::InstanceManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createInstanceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 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 &","createInstanceManager", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createInstanceManager", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstanceManager", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","createInstanceManager", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","createInstanceManager", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  result = (Ogre::InstanceManager *)(arg1)->createInstanceManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createInstanceManager(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 9) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager_createInstanceManager__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager_createInstanceManager__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_short(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SceneManager_createInstanceManager__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "SceneManager.createInstanceManager", 
    "    Ogre::InstanceManager * SceneManager.createInstanceManager(Ogre::String const &customName, Ogre::String const &meshName, Ogre::String const &groupName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch, Ogre::uint16 flags, unsigned short subMeshIdx)\n"
    "    Ogre::InstanceManager * SceneManager.createInstanceManager(Ogre::String const &customName, Ogre::String const &meshName, Ogre::String const &groupName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch, Ogre::uint16 flags)\n"
    "    Ogre::InstanceManager * SceneManager.createInstanceManager(Ogre::String const &customName, Ogre::String const &meshName, Ogre::String const &groupName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getInstanceManager(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::InstanceManager *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getInstanceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getInstanceManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::InstanceManager *)((Ogre::SceneManager const *)arg1)->getInstanceManager((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_hasInstanceManager(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasInstanceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasInstanceManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasInstanceManager((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyInstanceManager__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyInstanceManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyInstanceManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyInstanceManager((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyInstanceManager__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::InstanceManager *arg2 = (Ogre::InstanceManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","destroyInstanceManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::InstanceManager * >(argp2);
  (arg1)->destroyInstanceManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyInstanceManager(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__InstanceManager, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyInstanceManager__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyInstanceManager__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "SceneManager.destroyInstanceManager", 
    "    void SceneManager.destroyInstanceManager(Ogre::String const &name)\n"
    "    void SceneManager.destroyInstanceManager(Ogre::InstanceManager *instanceManager)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllInstanceManagers(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllInstanceManagers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllInstanceManagers();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getNumInstancesPerBatch__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  size_t arg6 ;
  Ogre::uint16 arg7 ;
  unsigned short arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  unsigned short val8 ;
  int ecode8 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getNumInstancesPerBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getNumInstancesPerBatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 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 &","getNumInstancesPerBatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","getNumInstancesPerBatch", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","getNumInstancesPerBatch", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","getNumInstancesPerBatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint16","getNumInstancesPerBatch", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint16 >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_short(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "unsigned short","getNumInstancesPerBatch", 8, argv[6] ));
  } 
  arg8 = static_cast< unsigned short >(val8);
  result = (arg1)->getNumInstancesPerBatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getNumInstancesPerBatch__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  size_t arg6 ;
  Ogre::uint16 arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getNumInstancesPerBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getNumInstancesPerBatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 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 &","getNumInstancesPerBatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","getNumInstancesPerBatch", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","getNumInstancesPerBatch", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","getNumInstancesPerBatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint16","getNumInstancesPerBatch", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::uint16 >(val7);
  result = (arg1)->getNumInstancesPerBatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6,arg7);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getNumInstancesPerBatch__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  Ogre::InstanceManager::InstancingTechnique arg5 ;
  size_t arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  int val5 ;
  int ecode5 = 0 ;
  size_t val6 ;
  int ecode6 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getNumInstancesPerBatch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getNumInstancesPerBatch", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 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 &","getNumInstancesPerBatch", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","getNumInstancesPerBatch", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getNumInstancesPerBatch", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::InstanceManager::InstancingTechnique","getNumInstancesPerBatch", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::InstanceManager::InstancingTechnique >(val5);
  ecode6 = SWIG_AsVal_size_t(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "size_t","getNumInstancesPerBatch", 6, argv[4] ));
  } 
  arg6 = static_cast< size_t >(val6);
  result = (arg1)->getNumInstancesPerBatch((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5,arg6);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_getNumInstancesPerBatch(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[9];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 9) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_SceneManager_getNumInstancesPerBatch__SWIG_2(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_SceneManager_getNumInstancesPerBatch__SWIG_1(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_int(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              {
                int res = SWIG_AsVal_size_t(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_unsigned_SS_short(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_unsigned_SS_short(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_SceneManager_getNumInstancesPerBatch__SWIG_0(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 9, "SceneManager.getNumInstancesPerBatch", 
    "    size_t SceneManager.getNumInstancesPerBatch(Ogre::String const &meshName, Ogre::String const &groupName, Ogre::String const &materialName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch, Ogre::uint16 flags, unsigned short subMeshIdx)\n"
    "    size_t SceneManager.getNumInstancesPerBatch(Ogre::String const &meshName, Ogre::String const &groupName, Ogre::String const &materialName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch, Ogre::uint16 flags)\n"
    "    size_t SceneManager.getNumInstancesPerBatch(Ogre::String const &meshName, Ogre::String const &groupName, Ogre::String const &materialName, Ogre::InstanceManager::InstancingTechnique technique, size_t numInstancesPerBatch)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createInstancedEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::InstancedEntity *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstancedEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createInstancedEntity", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstancedEntity", 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 &","createInstancedEntity", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstancedEntity", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::InstancedEntity *)(arg1)->createInstancedEntity((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__InstancedEntity, 0 |  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_SceneManager_destroyInstancedEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::InstancedEntity *arg2 = (Ogre::InstancedEntity *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyInstancedEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__InstancedEntity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstancedEntity *","destroyInstancedEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::InstancedEntity * >(argp2);
  (arg1)->destroyInstancedEntity(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__addDirtyInstanceManager(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::InstanceManager *arg2 = (Ogre::InstanceManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_addDirtyInstanceManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__InstanceManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::InstanceManager *","_addDirtyInstanceManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::InstanceManager * >(argp2);
  (arg1)->_addDirtyInstanceManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createMovableObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::NameValuePairList *arg4 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::MovableObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 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 &","createMovableObject", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4,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, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createMovableObject", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::NameValuePairList * >(argp4);
  result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::NameValuePairList const *)arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  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_SceneManager_createMovableObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 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 &","createMovableObject", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  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_SceneManager_createMovableObject__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::NameValuePairList *arg3 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::MovableObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,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, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createMovableObject", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::NameValuePairList * >(argp3);
  result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2,(Ogre::NameValuePairList const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createMovableObject__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::MovableObject *)(arg1)->createMovableObject((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyMovableObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyMovableObject", 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 &","destroyMovableObject", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyMovableObject", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->destroyMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyMovableObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","destroyMovableObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->destroyMovableObject(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_destroyMovableObject(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_destroyMovableObject__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_destroyMovableObject__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.destroyMovableObject", 
    "    void SceneManager.destroyMovableObject(Ogre::String const &name, Ogre::String const &typeName)\n"
    "    void SceneManager.destroyMovableObject(Ogre::MovableObject *m)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllMovableObjectsByType(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllMovableObjectsByType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","destroyAllMovableObjectsByType", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyAllMovableObjectsByType", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyAllMovableObjectsByType((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_destroyAllMovableObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyAllMovableObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->destroyAllMovableObjects();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getMovableObject(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMovableObject", 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 &","getMovableObject", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMovableObject", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::MovableObject *)((Ogre::SceneManager const *)arg1)->getMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  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_SceneManager_hasMovableObject(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","hasMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","hasMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasMovableObject", 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 &","hasMovableObject", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasMovableObject", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (bool)((Ogre::SceneManager const *)arg1)->hasMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  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_SceneManager_getMovableObjectIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SceneManager::MovableObjectIterator > 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getMovableObjectIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","getMovableObjectIterator", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMovableObjectIterator", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getMovableObjectIterator((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::SceneManager::MovableObjectIterator(static_cast< const Ogre::SceneManager::MovableObjectIterator& >(result))), SWIGTYPE_p_Ogre__SceneManager__MovableObjectIterator, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_injectMovableObject(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","injectMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","injectMovableObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->injectMovableObject(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_extractMovableObject__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","extractMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","extractMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","extractMovableObject", 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 &","extractMovableObject", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","extractMovableObject", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->extractMovableObject((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_extractMovableObject__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","extractMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","extractMovableObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->extractMovableObject(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_extractMovableObject(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObject, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_extractMovableObject__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_extractMovableObject__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.extractMovableObject", 
    "    void SceneManager.extractMovableObject(Ogre::String const &name, Ogre::String const &typeName)\n"
    "    void SceneManager.extractMovableObject(Ogre::MovableObject *m)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_extractAllMovableObjectsByType(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","extractAllMovableObjectsByType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","extractAllMovableObjectsByType", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","extractAllMovableObjectsByType", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->extractAllMovableObjectsByType((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setVisibilityMask(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::uint32 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setVisibilityMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setVisibilityMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setVisibilityMask(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getVisibilityMask(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getVisibilityMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::uint32)(arg1)->getVisibilityMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__getCombinedVisibilityMask(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","_getCombinedVisibilityMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::uint32)((Ogre::SceneManager const *)arg1)->_getCombinedVisibilityMask();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFindVisibleObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFindVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFindVisibleObjects", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFindVisibleObjects(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getFindVisibleObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getFindVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)(arg1)->getFindVisibleObjects();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setNormaliseNormalsOnScale(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setNormaliseNormalsOnScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setNormaliseNormalsOnScale", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setNormaliseNormalsOnScale(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getNormaliseNormalsOnScale(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getNormaliseNormalsOnScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getNormaliseNormalsOnScale();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setFlipCullingOnNegativeScale(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setFlipCullingOnNegativeScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setFlipCullingOnNegativeScale", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setFlipCullingOnNegativeScale(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getFlipCullingOnNegativeScale(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getFlipCullingOnNegativeScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getFlipCullingOnNegativeScale();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__injectRenderWithPass__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  Ogre::Renderable *arg3 = (Ogre::Renderable *) 0 ;
  bool arg4 ;
  bool arg5 ;
  Ogre::LightList *arg6 = (Ogre::LightList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_injectRenderWithPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","_injectRenderWithPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Renderable *","_injectRenderWithPass", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Renderable * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_injectRenderWithPass", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_injectRenderWithPass", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::LightList const *","_injectRenderWithPass", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::LightList * >(argp6);
  (arg1)->_injectRenderWithPass(arg2,arg3,arg4,arg5,(Ogre::LightList const *)arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__injectRenderWithPass__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  Ogre::Renderable *arg3 = (Ogre::Renderable *) 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_injectRenderWithPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","_injectRenderWithPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Renderable *","_injectRenderWithPass", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Renderable * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_injectRenderWithPass", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","_injectRenderWithPass", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->_injectRenderWithPass(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__injectRenderWithPass__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  Ogre::Renderable *arg3 = (Ogre::Renderable *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_injectRenderWithPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","_injectRenderWithPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Renderable *","_injectRenderWithPass", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Renderable * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_injectRenderWithPass", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->_injectRenderWithPass(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__injectRenderWithPass__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  Ogre::Renderable *arg3 = (Ogre::Renderable *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_injectRenderWithPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass *","_injectRenderWithPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Renderable *","_injectRenderWithPass", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Renderable * >(argp3);
  (arg1)->_injectRenderWithPass(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__injectRenderWithPass(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) 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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneManager__injectRenderWithPass__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneManager__injectRenderWithPass__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_SceneManager__injectRenderWithPass__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Renderable, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_SceneManager__injectRenderWithPass__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "SceneManager._injectRenderWithPass", 
    "    void SceneManager._injectRenderWithPass(Ogre::Pass *pass, Ogre::Renderable *rend, bool shadowDerivation, bool doLightIteration, Ogre::LightList const *manualLightList)\n"
    "    void SceneManager._injectRenderWithPass(Ogre::Pass *pass, Ogre::Renderable *rend, bool shadowDerivation, bool doLightIteration)\n"
    "    void SceneManager._injectRenderWithPass(Ogre::Pass *pass, Ogre::Renderable *rend, bool shadowDerivation)\n"
    "    void SceneManager._injectRenderWithPass(Ogre::Pass *pass, Ogre::Renderable *rend)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__suppressRenderStateChanges(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_suppressRenderStateChanges", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_suppressRenderStateChanges", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_suppressRenderStateChanges(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__areRenderStateChangesSuppressed(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","_areRenderStateChangesSuppressed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->_areRenderStateChangesSuppressed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setPass__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::Pass *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass const *","_setPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setPass", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","_setPass", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::Pass *)(arg1)->_setPass((Ogre::Pass const *)arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setPass__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::Pass *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass const *","_setPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setPass", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::Pass *)(arg1)->_setPass((Ogre::Pass const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__setPass__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Pass *arg2 = (Ogre::Pass *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::Pass *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_setPass", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Pass const *","_setPass", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Pass * >(argp2);
  result = (Ogre::Pass *)(arg1)->_setPass((Ogre::Pass const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Pass, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager__setPass(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager__setPass__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager__setPass__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Pass, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SceneManager__setPass__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager._setPass", 
    "    Ogre::Pass const * SceneManager._setPass(Ogre::Pass const *pass, bool evenIfSuppressed, bool shadowDerivation)\n"
    "    Ogre::Pass const * SceneManager._setPass(Ogre::Pass const *pass, bool evenIfSuppressed)\n"
    "    Ogre::Pass const * SceneManager._setPass(Ogre::Pass const *pass)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__markGpuParamsDirty(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_markGpuParamsDirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","_markGpuParamsDirty", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->_markGpuParamsDirty(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__suppressShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_suppressShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_suppressShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_suppressShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__areShadowsSuppressed(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","_areShadowsSuppressed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->_areShadowsSuppressed();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__renderQueueGroupObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::RenderQueueGroup *arg2 = (Ogre::RenderQueueGroup *) 0 ;
  Ogre::QueuedRenderableCollection::OrganisationMode arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_renderQueueGroupObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderQueueGroup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderQueueGroup *","_renderQueueGroupObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderQueueGroup * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::QueuedRenderableCollection::OrganisationMode","_renderQueueGroupObjects", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::QueuedRenderableCollection::OrganisationMode >(val3);
  (arg1)->_renderQueueGroupObjects(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setQueuedRenderableVisitor(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneManager::SceneMgrQueuedRenderableVisitor *arg2 = (Ogre::SceneManager::SceneMgrQueuedRenderableVisitor *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setQueuedRenderableVisitor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager::SceneMgrQueuedRenderableVisitor *","setQueuedRenderableVisitor", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager::SceneMgrQueuedRenderableVisitor * >(argp2);
  (arg1)->setQueuedRenderableVisitor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getQueuedRenderableVisitor(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager::SceneMgrQueuedRenderableVisitor *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getQueuedRenderableVisitor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::SceneManager::SceneMgrQueuedRenderableVisitor *)((Ogre::SceneManager const *)arg1)->getQueuedRenderableVisitor();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getDestinationRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystem *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","getDestinationRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::RenderSystem *)(arg1)->getDestinationRenderSystem();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getCurrentViewport(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Viewport *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getCurrentViewport", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Viewport *)((Ogre::SceneManager const *)arg1)->getCurrentViewport();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getVisibleObjectsBoundsInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::VisibleObjectsBoundsInfo *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getVisibleObjectsBoundsInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getVisibleObjectsBoundsInfo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::VisibleObjectsBoundsInfo *) &((Ogre::SceneManager const *)arg1)->getVisibleObjectsBoundsInfo((Ogre::Camera const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowCasterBoundsInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Light *arg2 = (Ogre::Light *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  Ogre::VisibleObjectsBoundsInfo *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCasterBoundsInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCasterBoundsInfo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getShadowCasterBoundsInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (Ogre::VisibleObjectsBoundsInfo *) &((Ogre::SceneManager const *)arg1)->getShadowCasterBoundsInfo((Ogre::Light const *)arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getShadowCasterBoundsInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Light *arg2 = (Ogre::Light *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::VisibleObjectsBoundsInfo *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCasterBoundsInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCasterBoundsInfo", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Light * >(argp2);
  result = (Ogre::VisibleObjectsBoundsInfo *) &((Ogre::SceneManager const *)arg1)->getShadowCasterBoundsInfo((Ogre::Light const *)arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_getShadowCasterBoundsInfo(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_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Light, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SceneManager_getShadowCasterBoundsInfo__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Light, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SceneManager_getShadowCasterBoundsInfo__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManager.getShadowCasterBoundsInfo", 
    "    Ogre::VisibleObjectsBoundsInfo const & SceneManager.getShadowCasterBoundsInfo(Ogre::Light const *light, size_t iteration)\n"
    "    Ogre::VisibleObjectsBoundsInfo const & SceneManager.getShadowCasterBoundsInfo(Ogre::Light const *light)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_setCameraRelativeRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setCameraRelativeRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCameraRelativeRendering", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCameraRelativeRendering(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_getCameraRelativeRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getCameraRelativeRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (bool)((Ogre::SceneManager const *)arg1)->getCameraRelativeRendering();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_addLodListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::LodListener *arg2 = (Ogre::LodListener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","addLodListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodListener *","addLodListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodListener * >(argp2);
  (arg1)->addLodListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_removeLodListener(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::LodListener *arg2 = (Ogre::LodListener *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","removeLodListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__LodListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::LodListener *","removeLodListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::LodListener * >(argp2);
  (arg1)->removeLodListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__notifyMovableObjectLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::MovableObjectLodChangedEvent *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_notifyMovableObjectLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MovableObjectLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObjectLodChangedEvent &","_notifyMovableObjectLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MovableObjectLodChangedEvent &","_notifyMovableObjectLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObjectLodChangedEvent * >(argp2);
  (arg1)->_notifyMovableObjectLodChanged(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__notifyEntityMeshLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::EntityMeshLodChangedEvent *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_notifyEntityMeshLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__EntityMeshLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EntityMeshLodChangedEvent &","_notifyEntityMeshLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::EntityMeshLodChangedEvent &","_notifyEntityMeshLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::EntityMeshLodChangedEvent * >(argp2);
  (arg1)->_notifyEntityMeshLodChanged(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__notifyEntityMaterialLodChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::EntityMaterialLodChangedEvent *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_notifyEntityMaterialLodChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__EntityMaterialLodChangedEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::EntityMaterialLodChangedEvent &","_notifyEntityMaterialLodChanged", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::EntityMaterialLodChangedEvent &","_notifyEntityMaterialLodChanged", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::EntityMaterialLodChangedEvent * >(argp2);
  (arg1)->_notifyEntityMaterialLodChanged(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager__handleLodEvents(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_handleLodEvents", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  (arg1)->_handleLodEvents();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManager_createMovableObject__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  VALUE arg4 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 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 &","createMovableObject", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  arg4 = argv[2];
  result = (Ogre::MovableObject *)Ogre_SceneManager_createMovableObject__SWIG_4(arg1,(std::string const &)*arg2,(std::string const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  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_SceneManager_createMovableObject__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  VALUE arg3 = (VALUE) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MovableObject *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_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createMovableObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(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( "", "Ogre::String const &","createMovableObject", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createMovableObject", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  arg3 = argv[1];
  result = (Ogre::MovableObject *)Ogre_SceneManager_createMovableObject__SWIG_5(arg1,(std::string const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManager_createMovableObject(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_Ogre__SceneManager, 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_SceneManager_createMovableObject__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, 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, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SceneManager_createMovableObject__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_SceneManager_createMovableObject__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        _v = (argv[2] != 0);
        if (_v) {
          return _wrap_SceneManager_createMovableObject__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, 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, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_SceneManager_createMovableObject__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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) {
          _v = (argv[3] != 0);
          if (_v) {
            return _wrap_SceneManager_createMovableObject__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "SceneManager.createMovableObject", 
    "    Ogre::MovableObject * SceneManager.createMovableObject(Ogre::String const &name, Ogre::String const &typeName, Ogre::NameValuePairList const *params)\n"
    "    Ogre::MovableObject * SceneManager.createMovableObject(Ogre::String const &name, Ogre::String const &typeName)\n"
    "    Ogre::MovableObject * SceneManager.createMovableObject(Ogre::String const &typeName, Ogre::NameValuePairList const *params)\n"
    "    Ogre::MovableObject * SceneManager.createMovableObject(Ogre::String const &typeName)\n"
    "    Ogre::MovableObject * SceneManager.createMovableObject(Ogre::String const &name, Ogre::String const &typeName, VALUE params)\n"
    "    Ogre::MovableObject * SceneManager.createMovableObject(Ogre::String const &typeName, VALUE params)\n");
  
  return Qnil;
}


swig_class SwigClassDefaultIntersectionSceneQuery;

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

SWIGINTERN VALUE
_wrap_new_DefaultIntersectionSceneQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultIntersectionSceneQuery";
  Ogre::DefaultIntersectionSceneQuery *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::DefaultIntersectionSceneQuery", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::DefaultIntersectionSceneQuery *)new Ogre::DefaultIntersectionSceneQuery(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultIntersectionSceneQuery(Ogre::DefaultIntersectionSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultIntersectionSceneQuery_execute(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultIntersectionSceneQuery *arg1 = (Ogre::DefaultIntersectionSceneQuery *) 0 ;
  Ogre::IntersectionSceneQueryListener *arg2 = (Ogre::IntersectionSceneQueryListener *) 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_Ogre__DefaultIntersectionSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultIntersectionSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultIntersectionSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IntersectionSceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IntersectionSceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IntersectionSceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultRaySceneQuery;

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

SWIGINTERN VALUE
_wrap_new_DefaultRaySceneQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultRaySceneQuery";
  Ogre::DefaultRaySceneQuery *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::DefaultRaySceneQuery", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::DefaultRaySceneQuery *)new Ogre::DefaultRaySceneQuery(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultRaySceneQuery(Ogre::DefaultRaySceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultRaySceneQuery_execute(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultRaySceneQuery *arg1 = (Ogre::DefaultRaySceneQuery *) 0 ;
  Ogre::RaySceneQueryListener *arg2 = (Ogre::RaySceneQueryListener *) 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_Ogre__DefaultRaySceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultRaySceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultRaySceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RaySceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RaySceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RaySceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultSphereSceneQuery;

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

SWIGINTERN VALUE
_wrap_new_DefaultSphereSceneQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultSphereSceneQuery";
  Ogre::DefaultSphereSceneQuery *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::DefaultSphereSceneQuery", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::DefaultSphereSceneQuery *)new Ogre::DefaultSphereSceneQuery(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultSphereSceneQuery(Ogre::DefaultSphereSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultSphereSceneQuery_execute(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultSphereSceneQuery *arg1 = (Ogre::DefaultSphereSceneQuery *) 0 ;
  Ogre::SceneQueryListener *arg2 = (Ogre::SceneQueryListener *) 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_Ogre__DefaultSphereSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultSphereSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultSphereSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultPlaneBoundedVolumeListSceneQuery;

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

SWIGINTERN VALUE
_wrap_new_DefaultPlaneBoundedVolumeListSceneQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultPlaneBoundedVolumeListSceneQuery";
  Ogre::DefaultPlaneBoundedVolumeListSceneQuery *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::DefaultPlaneBoundedVolumeListSceneQuery", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::DefaultPlaneBoundedVolumeListSceneQuery *)new Ogre::DefaultPlaneBoundedVolumeListSceneQuery(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultPlaneBoundedVolumeListSceneQuery(Ogre::DefaultPlaneBoundedVolumeListSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultPlaneBoundedVolumeListSceneQuery_execute(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultPlaneBoundedVolumeListSceneQuery *arg1 = (Ogre::DefaultPlaneBoundedVolumeListSceneQuery *) 0 ;
  Ogre::SceneQueryListener *arg2 = (Ogre::SceneQueryListener *) 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_Ogre__DefaultPlaneBoundedVolumeListSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultPlaneBoundedVolumeListSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultPlaneBoundedVolumeListSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultAxisAlignedBoxSceneQuery;

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

SWIGINTERN VALUE
_wrap_new_DefaultAxisAlignedBoxSceneQuery(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::DefaultAxisAlignedBoxSceneQuery";
  Ogre::DefaultAxisAlignedBoxSceneQuery *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::DefaultAxisAlignedBoxSceneQuery", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::DefaultAxisAlignedBoxSceneQuery *)new Ogre::DefaultAxisAlignedBoxSceneQuery(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultAxisAlignedBoxSceneQuery(Ogre::DefaultAxisAlignedBoxSceneQuery *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultAxisAlignedBoxSceneQuery_execute(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultAxisAlignedBoxSceneQuery *arg1 = (Ogre::DefaultAxisAlignedBoxSceneQuery *) 0 ;
  Ogre::SceneQueryListener *arg2 = (Ogre::SceneQueryListener *) 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_Ogre__DefaultAxisAlignedBoxSceneQuery, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultAxisAlignedBoxSceneQuery *","execute", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultAxisAlignedBoxSceneQuery * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneQueryListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneQueryListener *","execute", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneQueryListener * >(argp2);
  (arg1)->execute(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassSceneManagerMetaData;

SWIGINTERN VALUE
_wrap_SceneManagerMetaData_typeName_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 0 ;
  Ogre::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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","typeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(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( "", "Ogre::String const &","typeName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","typeName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->typeName = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerMetaData_typeName_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","typeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(argp1);
  result = (Ogre::String *) & ((arg1)->typeName);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerMetaData_description_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 0 ;
  Ogre::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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","description", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(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( "", "Ogre::String const &","description", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","description", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->description = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerMetaData_description_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","description", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(argp1);
  result = (Ogre::String *) & ((arg1)->description);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerMetaData_sceneTypeMask_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 0 ;
  Ogre::SceneTypeMask arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","sceneTypeMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneTypeMask","sceneTypeMask", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneTypeMask >(val2);
  if (arg1) (arg1)->sceneTypeMask = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerMetaData_sceneTypeMask_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneTypeMask 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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","sceneTypeMask", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(argp1);
  result = (Ogre::SceneTypeMask) ((arg1)->sceneTypeMask);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerMetaData_worldGeometrySupported_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","worldGeometrySupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","worldGeometrySupported", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->worldGeometrySupported = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerMetaData_worldGeometrySupported_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerMetaData *arg1 = (Ogre::SceneManagerMetaData *) 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_Ogre__SceneManagerMetaData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerMetaData *","worldGeometrySupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerMetaData * >(argp1);
  result = (bool) ((arg1)->worldGeometrySupported);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_SceneManagerMetaData(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SceneManagerMetaData";
  Ogre::SceneManagerMetaData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SceneManagerMetaData *)new Ogre::SceneManagerMetaData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneManagerMetaData(Ogre::SceneManagerMetaData *arg1) {
    delete arg1;
}

swig_class SwigClassSceneManagerFactory;

SWIGINTERN void
free_Ogre_SceneManagerFactory(Ogre::SceneManagerFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SceneManagerFactory_getMetaData(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerFactory *arg1 = (Ogre::SceneManagerFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManagerMetaData *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_Ogre__SceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerFactory const *","getMetaData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerFactory * >(argp1);
  result = (Ogre::SceneManagerMetaData *) &((Ogre::SceneManagerFactory const *)arg1)->getMetaData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerMetaData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerFactory *arg1 = (Ogre::SceneManagerFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__SceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createInstance((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerFactory *arg1 = (Ogre::SceneManagerFactory *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__SceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassRoot;

SWIGINTERN VALUE
_wrap_new_Root__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Root";
  Ogre::Root *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::Root", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Root", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Root", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Root", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res3 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Root", 3, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Root", 3, argv[2])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::Root *)new Ogre::Root((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Root__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Root";
  Ogre::Root *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::Root", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Root", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::Root", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Root", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Root *)new Ogre::Root((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_Root__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::Root";
  Ogre::Root *result = 0 ;
  
  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 &","Ogre::Root", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::Root", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::Root *)new Ogre::Root((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_Root__SWIG_3(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Root";
  Ogre::Root *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Root *)new Ogre::Root();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_Root(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_Root__SWIG_3(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_new_Root__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_new_Root__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_new_Root__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root.new", 
    "    Root.new(Ogre::String const &pluginFileName, Ogre::String const &configFileName, Ogre::String const &logFileName)\n"
    "    Root.new(Ogre::String const &pluginFileName, Ogre::String const &configFileName)\n"
    "    Root.new(Ogre::String const &pluginFileName)\n"
    "    Root.new()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_saveConfig(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","saveConfig", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  (arg1)->saveConfig();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_restoreConfig(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","restoreConfig", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)(arg1)->restoreConfig();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_showConfigDialog(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","showConfigDialog", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)(arg1)->showConfigDialog();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::RenderSystem *arg2 = (Ogre::RenderSystem *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","addRenderSystem", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystem * >(argp2);
  (arg1)->addRenderSystem(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getAvailableRenderers(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystemList *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getAvailableRenderers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::RenderSystemList *) &(arg1)->getAvailableRenderers();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__RenderSystem_p_Ogre__STLAllocatorT_Ogre__RenderSystem_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getRenderSystemByName(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderSystem *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getRenderSystemByName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","getRenderSystemByName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getRenderSystemByName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderSystem *)(arg1)->getRenderSystemByName((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_setRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::RenderSystem *arg2 = (Ogre::RenderSystem *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","setRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setRenderSystem", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystem * >(argp2);
  (arg1)->setRenderSystem(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderSystem *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::RenderSystem *)(arg1)->getRenderSystem();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_initialise__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::RenderWindow *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","initialise", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","initialise", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","initialise", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","initialise", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","initialise", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::RenderWindow *)(arg1)->initialise(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_initialise__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  bool arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::RenderWindow *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","initialise", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  {
    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 &","initialise", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","initialise", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::RenderWindow *)(arg1)->initialise(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_initialise__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  Ogre::RenderWindow *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","initialise", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","initialise", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (Ogre::RenderWindow *)(arg1)->initialise(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_initialise(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Root_initialise__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _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_Root_initialise__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Root_initialise__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Root.initialise", 
    "    Ogre::RenderWindow * Root.initialise(bool autoCreateWindow, Ogre::String const &windowTitle, Ogre::String const &customCapabilitiesConfig)\n"
    "    Ogre::RenderWindow * Root.initialise(bool autoCreateWindow, Ogre::String const &windowTitle)\n"
    "    Ogre::RenderWindow * Root.initialise(bool autoCreateWindow)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_isInitialised(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","isInitialised", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)((Ogre::Root const *)arg1)->isInitialised();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_useCustomRenderSystemCapabilities(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::RenderSystemCapabilities *arg2 = (Ogre::RenderSystemCapabilities *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","useCustomRenderSystemCapabilities", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystemCapabilities, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystemCapabilities *","useCustomRenderSystemCapabilities", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystemCapabilities * >(argp2);
  (arg1)->useCustomRenderSystemCapabilities(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getRemoveRenderQueueStructuresOnClear(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getRemoveRenderQueueStructuresOnClear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)((Ogre::Root const *)arg1)->getRemoveRenderQueueStructuresOnClear();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_setRemoveRenderQueueStructuresOnClear(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","setRemoveRenderQueueStructuresOnClear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setRemoveRenderQueueStructuresOnClear", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setRemoveRenderQueueStructuresOnClear(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addSceneManagerFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::SceneManagerFactory *arg2 = (Ogre::SceneManagerFactory *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addSceneManagerFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManagerFactory *","addSceneManagerFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManagerFactory * >(argp2);
  (arg1)->addSceneManagerFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_removeSceneManagerFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::SceneManagerFactory *arg2 = (Ogre::SceneManagerFactory *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","removeSceneManagerFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManagerFactory *","removeSceneManagerFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManagerFactory * >(argp2);
  (arg1)->removeSceneManagerFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getSceneManagerMetaData(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManagerMetaData *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getSceneManagerMetaData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","getSceneManagerMetaData", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSceneManagerMetaData", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManagerMetaData *)((Ogre::Root const *)arg1)->getSceneManagerMetaData((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerMetaData, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getSceneManagerMetaDataIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SceneManagerEnumerator::MetaDataIterator > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getSceneManagerMetaDataIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = ((Ogre::Root const *)arg1)->getSceneManagerMetaDataIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::MetaDataIterator(static_cast< const Ogre::SceneManagerEnumerator::MetaDataIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__MetaDataIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createSceneManager__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 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 &","createSceneManager", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  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_Root_createSceneManager__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createSceneManager__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::SceneTypeMask arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneTypeMask","createSceneManager", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneTypeMask >(val2);
  {
    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 &","createSceneManager", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createSceneManager__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::SceneTypeMask arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::SceneManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneTypeMask","createSceneManager", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneTypeMask >(val2);
  result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_createSceneManager(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Root_createSceneManager__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_Root_createSceneManager__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _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_Root_createSceneManager__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_Root_createSceneManager__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Root.createSceneManager", 
    "    Ogre::SceneManager * Root.createSceneManager(Ogre::String const &typeName, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * Root.createSceneManager(Ogre::String const &typeName)\n"
    "    Ogre::SceneManager * Root.createSceneManager(Ogre::SceneTypeMask typeMask, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * Root.createSceneManager(Ogre::SceneTypeMask typeMask)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_destroySceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","destroySceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroySceneManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->destroySceneManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","getSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSceneManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManager *)((Ogre::Root const *)arg1)->getSceneManager((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_hasSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","hasSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","hasSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasSceneManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::Root const *)arg1)->hasSceneManager((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getSceneManagerIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SceneManagerEnumerator::SceneManagerIterator > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getSceneManagerIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (arg1)->getSceneManagerIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::SceneManagerIterator(static_cast< const Ogre::SceneManagerEnumerator::SceneManagerIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__SceneManagerIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getTextureManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TextureManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getTextureManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::TextureManager *)(arg1)->getTextureManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TextureManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getMeshManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MeshManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getMeshManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::MeshManager *)(arg1)->getMeshManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MeshManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getErrorDescription(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  Ogre::String 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getErrorDescription", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getErrorDescription", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  result = (arg1)->getErrorDescription(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addFrameListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::FrameListener *arg2 = (Ogre::FrameListener *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addFrameListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__FrameListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameListener *","addFrameListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::FrameListener * >(argp2);
  (arg1)->addFrameListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_removeFrameListener(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::FrameListener *arg2 = (Ogre::FrameListener *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","removeFrameListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__FrameListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameListener *","removeFrameListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::FrameListener * >(argp2);
  (arg1)->removeFrameListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_queueEndRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","queueEndRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  (arg1)->queueEndRendering();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_startRendering(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","startRendering", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  (arg1)->startRendering();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_renderOneFrame__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","renderOneFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)(arg1)->renderOneFrame();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_renderOneFrame__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","renderOneFrame", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","renderOneFrame", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  result = (bool)(arg1)->renderOneFrame(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_renderOneFrame(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Root_renderOneFrame__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Root_renderOneFrame__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root.renderOneFrame", 
    "    bool Root.renderOneFrame()\n"
    "    bool Root.renderOneFrame(Ogre::Real timeSinceLastFrame)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_shutdown(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","shutdown", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  (arg1)->shutdown();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addResourceLocation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","addResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 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 &","addResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","addResourceLocation", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","addResourceLocation", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4,arg5);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addResourceLocation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","addResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 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 &","addResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","addResourceLocation", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addResourceLocation__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","addResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 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 &","addResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->addResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_addResourceLocation(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_Ogre__Root, 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_Root_addResourceLocation__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Root_addResourceLocation__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Root_addResourceLocation__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Root.addResourceLocation", 
    "    void Root.addResourceLocation(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &groupName, bool recursive)\n"
    "    void Root.addResourceLocation(Ogre::String const &name, Ogre::String const &locType, Ogre::String const &groupName)\n"
    "    void Root.addResourceLocation(Ogre::String const &name, Ogre::String const &locType)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_removeResourceLocation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","removeResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","removeResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeResourceLocation", 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 &","removeResourceLocation", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeResourceLocation", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->removeResourceLocation((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_removeResourceLocation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","removeResourceLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","removeResourceLocation", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeResourceLocation", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeResourceLocation((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_removeResourceLocation(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_Ogre__Root, 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_Root_removeResourceLocation__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_Root_removeResourceLocation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Root.removeResourceLocation", 
    "    void Root.removeResourceLocation(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void Root.removeResourceLocation(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createFileStream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  Ogre::String *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  int res5 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > result;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createFileStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createFileStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 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 &","createFileStream", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createFileStream", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  {
    std::string *ptr = (std::string *)0;
    res5 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res5)) {
      SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::String const &","createFileStream", 5, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 5, argv[3])); 
    }
    arg5 = ptr;
  }
  result = (arg1)->createFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,(Ogre::String const &)*arg5);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res5)) delete arg5;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createFileStream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createFileStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createFileStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 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 &","createFileStream", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","createFileStream", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->createFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_Root_createFileStream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createFileStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createFileStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 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 &","createFileStream", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->createFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_Root_createFileStream__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createFileStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createFileStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createFileStream", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->createFileStream((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_createFileStream(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_Ogre__Root, 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_Root_createFileStream__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_Root_createFileStream__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Root_createFileStream__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            int res = SWIG_AsPtr_std_string(argv[4], (std::string**)(0));
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Root_createFileStream__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Root.createFileStream", 
    "    Ogre::DataStreamPtr Root.createFileStream(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite, Ogre::String const &locationPattern)\n"
    "    Ogre::DataStreamPtr Root.createFileStream(Ogre::String const &filename, Ogre::String const &groupName, bool overwrite)\n"
    "    Ogre::DataStreamPtr Root.createFileStream(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr Root.createFileStream(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_openFileStream__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","openFileStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","openFileStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openFileStream", 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 &","openFileStream", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openFileStream", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","openFileStream", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openFileStream", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (arg1)->openFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_openFileStream__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","openFileStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","openFileStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openFileStream", 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 &","openFileStream", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openFileStream", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->openFileStream((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_Root_openFileStream__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","openFileStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","openFileStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","openFileStream", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->openFileStream((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_openFileStream(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_Ogre__Root, 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_Root_openFileStream__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_Root_openFileStream__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Root_openFileStream__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Root.openFileStream", 
    "    Ogre::DataStreamPtr Root.openFileStream(Ogre::String const &filename, Ogre::String const &groupName, Ogre::String const &locationPattern)\n"
    "    Ogre::DataStreamPtr Root.openFileStream(Ogre::String const &filename, Ogre::String const &groupName)\n"
    "    Ogre::DataStreamPtr Root.openFileStream(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_convertColourValue(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::ColourValue *arg2 = 0 ;
  Ogre::uint32 *arg3 = (Ogre::uint32 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","convertColourValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","convertColourValue", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","convertColourValue", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_unsigned_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::uint32 *","convertColourValue", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::uint32 * >(argp3);
  (arg1)->convertColourValue((Ogre::ColourValue const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getAutoCreatedWindow(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderWindow *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getAutoCreatedWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::RenderWindow *)(arg1)->getAutoCreatedWindow();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createRenderWindow__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bool arg5 ;
  Ogre::NameValuePairList *arg6 = (Ogre::NameValuePairList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  Ogre::RenderWindow *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createRenderWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createRenderWindow", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createRenderWindow", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","createRenderWindow", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(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","createRenderWindow", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createRenderWindow", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,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, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::NameValuePairList const *","createRenderWindow", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::NameValuePairList * >(argp6);
  result = (Ogre::RenderWindow *)(arg1)->createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5,(Ogre::NameValuePairList const *)arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createRenderWindow__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  unsigned int arg3 ;
  unsigned int arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned int val3 ;
  int ecode3 = 0 ;
  unsigned int val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  Ogre::RenderWindow *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createRenderWindow", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createRenderWindow", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createRenderWindow", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned int","createRenderWindow", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned int >(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","createRenderWindow", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned int >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","createRenderWindow", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::RenderWindow *)(arg1)->createRenderWindow((Ogre::String const &)*arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_createRenderWindow(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_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_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_Root_createRenderWindow__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_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_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, 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, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Root_createRenderWindow__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Root.createRenderWindow", 
    "    Ogre::RenderWindow * Root.createRenderWindow(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen, Ogre::NameValuePairList const *miscParams)\n"
    "    Ogre::RenderWindow * Root.createRenderWindow(Ogre::String const &name, unsigned int width, unsigned int height, bool fullScreen)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createRenderWindows(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::RenderWindowDescriptionList *arg2 = 0 ;
  Ogre::RenderWindowList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createRenderWindows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindowDescription_Ogre__STLAllocatorT_Ogre__RenderWindowDescription_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderWindowDescriptionList const &","createRenderWindows", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderWindowDescriptionList const &","createRenderWindows", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderWindowDescriptionList * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::RenderWindowList &","createRenderWindows", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderWindowList &","createRenderWindows", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::RenderWindowList * >(argp3);
  result = (bool)(arg1)->createRenderWindows((Ogre::RenderWindowDescriptionList const &)*arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_detachRenderTarget__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::RenderTarget *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","detachRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","detachRenderTarget", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  result = (Ogre::RenderTarget *)(arg1)->detachRenderTarget(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_detachRenderTarget__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderTarget *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","detachRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","detachRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","detachRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderTarget *)(arg1)->detachRenderTarget((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_detachRenderTarget(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Root_detachRenderTarget__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_Root_detachRenderTarget__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root.detachRenderTarget", 
    "    Ogre::RenderTarget * Root.detachRenderTarget(Ogre::RenderTarget *pWin)\n"
    "    Ogre::RenderTarget * Root.detachRenderTarget(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_destroyRenderTarget__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::RenderTarget *arg2 = (Ogre::RenderTarget *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","destroyRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderTarget *","destroyRenderTarget", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderTarget * >(argp2);
  (arg1)->destroyRenderTarget(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_destroyRenderTarget__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","destroyRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","destroyRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyRenderTarget((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_destroyRenderTarget(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderTarget, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Root_destroyRenderTarget__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 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_Root_destroyRenderTarget__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root.destroyRenderTarget", 
    "    void Root.destroyRenderTarget(Ogre::RenderTarget *target)\n"
    "    void Root.destroyRenderTarget(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getRenderTarget(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderTarget *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getRenderTarget", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","getRenderTarget", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getRenderTarget", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderTarget *)(arg1)->getRenderTarget((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderTarget, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_loadPlugin(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","loadPlugin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","loadPlugin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadPlugin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->loadPlugin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_unloadPlugin(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","unloadPlugin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","unloadPlugin", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","unloadPlugin", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->unloadPlugin((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_installPlugin(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::Plugin *arg2 = (Ogre::Plugin *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","installPlugin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Plugin, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plugin *","installPlugin", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Plugin * >(argp2);
  (arg1)->installPlugin(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_uninstallPlugin(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::Plugin *arg2 = (Ogre::Plugin *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","uninstallPlugin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Plugin, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plugin *","uninstallPlugin", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Plugin * >(argp2);
  (arg1)->uninstallPlugin(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getInstalledPlugins(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Root::PluginInstanceList *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getInstalledPlugins", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::Root::PluginInstanceList *) &((Ogre::Root const *)arg1)->getInstalledPlugins();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getTimer(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Timer *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getTimer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::Timer *)(arg1)->getTimer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Timer, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__fireFrameStarted__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::FrameEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_fireFrameStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent &","_fireFrameStarted", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent &","_fireFrameStarted", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  result = (bool)(arg1)->_fireFrameStarted(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__fireFrameRenderingQueued__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::FrameEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_fireFrameRenderingQueued", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent &","_fireFrameRenderingQueued", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent &","_fireFrameRenderingQueued", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  result = (bool)(arg1)->_fireFrameRenderingQueued(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__fireFrameEnded__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::FrameEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_fireFrameEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent &","_fireFrameEnded", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent &","_fireFrameEnded", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  result = (bool)(arg1)->_fireFrameEnded(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__fireFrameStarted__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_fireFrameStarted", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)(arg1)->_fireFrameStarted();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__fireFrameStarted(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Root__fireFrameStarted__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__FrameEvent, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Root__fireFrameStarted__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._fireFrameStarted", 
    "    bool Root._fireFrameStarted(Ogre::FrameEvent &evt)\n"
    "    bool Root._fireFrameStarted()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__fireFrameRenderingQueued__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_fireFrameRenderingQueued", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)(arg1)->_fireFrameRenderingQueued();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__fireFrameRenderingQueued(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Root__fireFrameRenderingQueued__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__FrameEvent, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Root__fireFrameRenderingQueued__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._fireFrameRenderingQueued", 
    "    bool Root._fireFrameRenderingQueued(Ogre::FrameEvent &evt)\n"
    "    bool Root._fireFrameRenderingQueued()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__fireFrameEnded__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_fireFrameEnded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)(arg1)->_fireFrameEnded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__fireFrameEnded(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Root__fireFrameEnded__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__FrameEvent, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Root__fireFrameEnded__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._fireFrameEnded", 
    "    bool Root._fireFrameEnded(Ogre::FrameEvent &evt)\n"
    "    bool Root._fireFrameEnded()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getNextFrameNumber(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getNextFrameNumber", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (unsigned long)((Ogre::Root const *)arg1)->getNextFrameNumber();
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__getCurrentSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","_getCurrentSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::Root const *)arg1)->_getCurrentSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__pushCurrentSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_pushCurrentSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_pushCurrentSceneManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->_pushCurrentSceneManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__popCurrentSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_popCurrentSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","_popCurrentSceneManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->_popCurrentSceneManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__updateAllRenderTargets__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_updateAllRenderTargets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)(arg1)->_updateAllRenderTargets();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__updateAllRenderTargets__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::FrameEvent *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_updateAllRenderTargets", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__FrameEvent,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::FrameEvent &","_updateAllRenderTargets", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::FrameEvent &","_updateAllRenderTargets", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::FrameEvent * >(argp2);
  result = (bool)(arg1)->_updateAllRenderTargets(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root__updateAllRenderTargets(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Root__updateAllRenderTargets__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__FrameEvent, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Root__updateAllRenderTargets__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Root._updateAllRenderTargets", 
    "    bool Root._updateAllRenderTargets()\n"
    "    bool Root._updateAllRenderTargets(Ogre::FrameEvent &evt)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_createRenderQueueInvocationSequence(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderQueueInvocationSequence *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","createRenderQueueInvocationSequence", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","createRenderQueueInvocationSequence", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createRenderQueueInvocationSequence", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderQueueInvocationSequence *)(arg1)->createRenderQueueInvocationSequence((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getRenderQueueInvocationSequence(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::RenderQueueInvocationSequence *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getRenderQueueInvocationSequence", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","getRenderQueueInvocationSequence", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getRenderQueueInvocationSequence", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::RenderQueueInvocationSequence *)(arg1)->getRenderQueueInvocationSequence((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_destroyRenderQueueInvocationSequence(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","destroyRenderQueueInvocationSequence", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","destroyRenderQueueInvocationSequence", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyRenderQueueInvocationSequence", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyRenderQueueInvocationSequence((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_destroyAllRenderQueueInvocationSequences(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","destroyAllRenderQueueInvocationSequences", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  (arg1)->destroyAllRenderQueueInvocationSequences();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Root *) &Ogre::Root::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Root, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Root *)Ogre::Root::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Root, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_clearEventTimes(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","clearEventTimes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  (arg1)->clearEventTimes();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_setFrameSmoothingPeriod(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","setFrameSmoothingPeriod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setFrameSmoothingPeriod", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setFrameSmoothingPeriod(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getFrameSmoothingPeriod(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getFrameSmoothingPeriod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::Real)((Ogre::Root const *)arg1)->getFrameSmoothingPeriod();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addMovableObjectFactory__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::MovableObjectFactory *arg2 = (Ogre::MovableObjectFactory *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addMovableObjectFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","addMovableObjectFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","addMovableObjectFactory", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->addMovableObjectFactory(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_addMovableObjectFactory__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::MovableObjectFactory *arg2 = (Ogre::MovableObjectFactory *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","addMovableObjectFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","addMovableObjectFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp2);
  (arg1)->addMovableObjectFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Root_addMovableObjectFactory(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_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObjectFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Root_addMovableObjectFactory__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Root, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__MovableObjectFactory, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Root_addMovableObjectFactory__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Root.addMovableObjectFactory", 
    "    void Root.addMovableObjectFactory(Ogre::MovableObjectFactory *fact, bool overrideExisting)\n"
    "    void Root.addMovableObjectFactory(Ogre::MovableObjectFactory *fact)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_removeMovableObjectFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::MovableObjectFactory *arg2 = (Ogre::MovableObjectFactory *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","removeMovableObjectFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObjectFactory *","removeMovableObjectFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObjectFactory * >(argp2);
  (arg1)->removeMovableObjectFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_hasMovableObjectFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","hasMovableObjectFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","hasMovableObjectFactory", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasMovableObjectFactory", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::Root const *)arg1)->hasMovableObjectFactory((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getMovableObjectFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::MovableObjectFactory *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getMovableObjectFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(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( "", "Ogre::String const &","getMovableObjectFactory", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMovableObjectFactory", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::MovableObjectFactory *)(arg1)->getMovableObjectFactory((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObjectFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root__allocateNextMovableObjectTypeFlag(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","_allocateNextMovableObjectTypeFlag", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::uint32)(arg1)->_allocateNextMovableObjectTypeFlag();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getMovableObjectFactoryIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::Root::MovableObjectFactoryIterator > 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getMovableObjectFactoryIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = ((Ogre::Root const *)arg1)->getMovableObjectFactoryIterator();
  vresult = SWIG_NewPointerObj((new Ogre::Root::MovableObjectFactoryIterator(static_cast< const Ogre::Root::MovableObjectFactoryIterator& >(result))), SWIGTYPE_p_Ogre__Root__MovableObjectFactoryIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getDisplayMonitorCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getDisplayMonitorCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (unsigned int)((Ogre::Root const *)arg1)->getDisplayMonitorCount();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getWorkQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::WorkQueue *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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","getWorkQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::WorkQueue *)((Ogre::Root const *)arg1)->getWorkQueue();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_setWorkQueue(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::WorkQueue *arg2 = (Ogre::WorkQueue *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","setWorkQueue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue *","setWorkQueue", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue * >(argp2);
  (arg1)->setWorkQueue(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_setBlendIndicesGpuRedundant(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","setBlendIndicesGpuRedundant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBlendIndicesGpuRedundant", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBlendIndicesGpuRedundant(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_isBlendIndicesGpuRedundant(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","isBlendIndicesGpuRedundant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)((Ogre::Root const *)arg1)->isBlendIndicesGpuRedundant();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_setBlendWeightsGpuRedundant(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","setBlendWeightsGpuRedundant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBlendWeightsGpuRedundant", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBlendWeightsGpuRedundant(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_isBlendWeightsGpuRedundant(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root const *","isBlendWeightsGpuRedundant", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (bool)((Ogre::Root const *)arg1)->isBlendWeightsGpuRedundant();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_setDefaultMinPixelSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","setDefaultMinPixelSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultMinPixelSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDefaultMinPixelSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getDefaultMinPixelSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getDefaultMinPixelSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (Ogre::Real)(arg1)->getDefaultMinPixelSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_getAvailableRendererArray(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  VALUE 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","getAvailableRendererArray", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  result = (VALUE)Ogre_Root_getAvailableRendererArray(arg1);
  vresult = result;
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Root_destruct(int argc, VALUE *argv, VALUE self) {
  Ogre::Root *arg1 = (Ogre::Root *) 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_Ogre__Root, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Root *","destruct", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Root * >(argp1);
  Ogre_Root_destruct(arg1);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultSceneManagerFactory;

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

SWIGINTERN VALUE
_wrap_new_DefaultSceneManagerFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::DefaultSceneManagerFactory";
  Ogre::DefaultSceneManagerFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::DefaultSceneManagerFactory *)new Ogre::DefaultSceneManagerFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultSceneManagerFactory(Ogre::DefaultSceneManagerFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultSceneManagerFactory_FACTORY_TYPE_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::DefaultSceneManagerFactory::FACTORY_TYPE_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_DefaultSceneManagerFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultSceneManagerFactory *arg1 = (Ogre::DefaultSceneManagerFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__DefaultSceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultSceneManagerFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultSceneManagerFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createInstance((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_DefaultSceneManagerFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultSceneManagerFactory *arg1 = (Ogre::DefaultSceneManagerFactory *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__DefaultSceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultSceneManagerFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultSceneManagerFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassDefaultSceneManager;

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

SWIGINTERN VALUE
_wrap_new_DefaultSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::DefaultSceneManager";
  Ogre::DefaultSceneManager *result = 0 ;
  
  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 &","Ogre::DefaultSceneManager", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::DefaultSceneManager", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::DefaultSceneManager *)new Ogre::DefaultSceneManager((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_DefaultSceneManager(Ogre::DefaultSceneManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_DefaultSceneManager_getTypeName(int argc, VALUE *argv, VALUE self) {
  Ogre::DefaultSceneManager *arg1 = (Ogre::DefaultSceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__DefaultSceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DefaultSceneManager const *","getTypeName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::DefaultSceneManager * >(argp1);
  result = (Ogre::String *) &((Ogre::DefaultSceneManager const *)arg1)->getTypeName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSceneManagerEnumerator;

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

SWIGINTERN VALUE
_wrap_new_SceneManagerEnumerator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SceneManagerEnumerator";
  Ogre::SceneManagerEnumerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SceneManagerEnumerator *)new Ogre::SceneManagerEnumerator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SceneManagerEnumerator(Ogre::SceneManagerEnumerator *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_addFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::SceneManagerFactory *arg2 = (Ogre::SceneManagerFactory *) 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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","addFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManagerFactory *","addFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManagerFactory * >(argp2);
  (arg1)->addFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_removeFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::SceneManagerFactory *arg2 = (Ogre::SceneManagerFactory *) 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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","removeFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManagerFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManagerFactory *","removeFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManagerFactory * >(argp2);
  (arg1)->removeFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_getMetaData(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManagerMetaData *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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator const *","getMetaData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(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( "", "Ogre::String const &","getMetaData", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getMetaData", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManagerMetaData *)((Ogre::SceneManagerEnumerator const *)arg1)->getMetaData((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerMetaData, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_getMetaDataIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SceneManagerEnumerator::MetaDataIterator > 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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator const *","getMetaDataIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  result = ((Ogre::SceneManagerEnumerator const *)arg1)->getMetaDataIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::MetaDataIterator(static_cast< const Ogre::SceneManagerEnumerator::MetaDataIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__MetaDataIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_createSceneManager__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(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( "", "Ogre::String const &","createSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 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 &","createSceneManager", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  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_SceneManagerEnumerator_createSceneManager__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(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( "", "Ogre::String const &","createSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createSceneManager((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_createSceneManager__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::SceneTypeMask arg2 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneTypeMask","createSceneManager", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneTypeMask >(val2);
  {
    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 &","createSceneManager", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSceneManager", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_createSceneManager__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::SceneTypeMask arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::SceneManager *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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","createSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::SceneTypeMask","createSceneManager", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::SceneTypeMask >(val2);
  result = (Ogre::SceneManager *)(arg1)->createSceneManager(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SceneManagerEnumerator_createSceneManager(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_Ogre__SceneManagerEnumerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_SceneManagerEnumerator_createSceneManager__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManagerEnumerator, 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_SceneManagerEnumerator_createSceneManager__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManagerEnumerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_short(argv[1], NULL);
        _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_SceneManagerEnumerator_createSceneManager__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManagerEnumerator, 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_SceneManagerEnumerator_createSceneManager__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SceneManagerEnumerator.createSceneManager", 
    "    Ogre::SceneManager * SceneManagerEnumerator.createSceneManager(Ogre::String const &typeName, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * SceneManagerEnumerator.createSceneManager(Ogre::String const &typeName)\n"
    "    Ogre::SceneManager * SceneManagerEnumerator.createSceneManager(Ogre::SceneTypeMask typeMask, Ogre::String const &instanceName)\n"
    "    Ogre::SceneManager * SceneManagerEnumerator.createSceneManager(Ogre::SceneTypeMask typeMask)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_destroySceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","destroySceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","destroySceneManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->destroySceneManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::SceneManager *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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(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( "", "Ogre::String const &","getSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSceneManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::SceneManager *)((Ogre::SceneManagerEnumerator const *)arg1)->getSceneManager((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_hasSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator const *","hasSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(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( "", "Ogre::String const &","hasSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","hasSceneManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)((Ogre::SceneManagerEnumerator const *)arg1)->hasSceneManager((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_getSceneManagerIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SceneManagerEnumerator::SceneManagerIterator > 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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","getSceneManagerIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  result = (arg1)->getSceneManagerIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SceneManagerEnumerator::SceneManagerIterator(static_cast< const Ogre::SceneManagerEnumerator::SceneManagerIterator& >(result))), SWIGTYPE_p_Ogre__SceneManagerEnumerator__SceneManagerIterator, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_setRenderSystem(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 0 ;
  Ogre::RenderSystem *arg2 = (Ogre::RenderSystem *) 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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","setRenderSystem", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderSystem, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderSystem *","setRenderSystem", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderSystem * >(argp2);
  (arg1)->setRenderSystem(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_shutdownAll(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *arg1 = (Ogre::SceneManagerEnumerator *) 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_Ogre__SceneManagerEnumerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManagerEnumerator *","shutdownAll", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManagerEnumerator * >(argp1);
  (arg1)->shutdownAll();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SceneManagerEnumerator *) &Ogre::SceneManagerEnumerator::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerEnumerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SceneManagerEnumerator_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManagerEnumerator *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SceneManagerEnumerator *)Ogre::SceneManagerEnumerator::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManagerEnumerator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassScriptToken;

SWIGINTERN VALUE
_wrap_ScriptToken_lexeme_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  Ogre::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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","lexeme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(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( "", "Ogre::String const &","lexeme", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","lexeme", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->lexeme = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptToken_lexeme_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","lexeme", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(argp1);
  result = (Ogre::String *) & ((arg1)->lexeme);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptToken_file_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  Ogre::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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","file", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(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( "", "Ogre::String const &","file", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","file", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->file = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptToken_file_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","file", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(argp1);
  result = (Ogre::String *) & ((arg1)->file);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptToken_type_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  Ogre::uint32 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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","type", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  if (arg1) (arg1)->type = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptToken_type_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","type", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(argp1);
  result = (Ogre::uint32) ((arg1)->type);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptToken_line_set(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  Ogre::uint32 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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","line", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","line", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  if (arg1) (arg1)->line = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptToken_line_get(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptToken *arg1 = (Ogre::ScriptToken *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__ScriptToken, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptToken *","line", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptToken * >(argp1);
  result = (Ogre::uint32) ((arg1)->line);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ScriptToken(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ScriptToken";
  Ogre::ScriptToken *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptToken *)new Ogre::ScriptToken();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptToken(Ogre::ScriptToken *arg1) {
    delete arg1;
}

swig_class SwigClassScriptLexer;

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

SWIGINTERN VALUE
_wrap_new_ScriptLexer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ScriptLexer";
  Ogre::ScriptLexer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptLexer *)new Ogre::ScriptLexer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptLexer(Ogre::ScriptLexer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ScriptLexer_tokenize(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptLexer *arg1 = (Ogre::ScriptLexer *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::ScriptTokenPtr,Ogre::STLAllocator< Ogre::ScriptTokenPtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ScriptLexer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptLexer *","tokenize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptLexer * >(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( "", "Ogre::String const &","tokenize", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","tokenize", 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 &","tokenize", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","tokenize", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (arg1)->tokenize((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj((new Ogre::ScriptTokenListPtr(static_cast< const Ogre::ScriptTokenListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t, 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;
}


swig_class SwigClassScriptParser;

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

SWIGINTERN VALUE
_wrap_new_ScriptParser(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ScriptParser";
  Ogre::ScriptParser *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ScriptParser *)new Ogre::ScriptParser();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ScriptParser(Ogre::ScriptParser *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ScriptParser_parse(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptParser *arg1 = (Ogre::ScriptParser *) 0 ;
  Ogre::ScriptTokenListPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::ConcreteNodePtr,Ogre::STLAllocator< Ogre::ConcreteNodePtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ScriptParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptParser *","parse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptParser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptTokenListPtr const &","parse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ScriptTokenListPtr const &","parse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptTokenListPtr * >(argp2);
  result = (arg1)->parse((Ogre::ScriptTokenListPtr const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ConcreteNodeListPtr(static_cast< const Ogre::ConcreteNodeListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptParser_parseChunk(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptParser *arg1 = (Ogre::ScriptParser *) 0 ;
  Ogre::ScriptTokenListPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::list< Ogre::ConcreteNodePtr,Ogre::STLAllocator< Ogre::ConcreteNodePtr,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ScriptParser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptParser *","parseChunk", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptParser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__ScriptTokenPtr_Ogre__STLAllocatorT_Ogre__ScriptTokenPtr_Ogre__GeneralAllocPolicy_t_t__type_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptTokenListPtr const &","parseChunk", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ScriptTokenListPtr const &","parseChunk", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptTokenListPtr * >(argp2);
  result = (arg1)->parseChunk((Ogre::ScriptTokenListPtr const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::ConcreteNodeListPtr(static_cast< const Ogre::ConcreteNodeListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__listT_Ogre__ConcreteNodePtr_Ogre__STLAllocatorT_Ogre__ConcreteNodePtr_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassScriptTranslator;

SWIGINTERN VALUE
_wrap_ScriptTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptTranslator *arg1 = (Ogre::ScriptTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__ScriptTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassScriptTranslatorManager;

SWIGINTERN void
free_Ogre_ScriptTranslatorManager(Ogre::ScriptTranslatorManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ScriptTranslatorManager_getNumTranslators(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptTranslatorManager *arg1 = (Ogre::ScriptTranslatorManager *) 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_Ogre__ScriptTranslatorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptTranslatorManager const *","getNumTranslators", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptTranslatorManager * >(argp1);
  result = ((Ogre::ScriptTranslatorManager const *)arg1)->getNumTranslators();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ScriptTranslatorManager_getTranslator(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptTranslatorManager *arg1 = (Ogre::ScriptTranslatorManager *) 0 ;
  Ogre::AbstractNodePtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ScriptTranslator *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_Ogre__ScriptTranslatorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptTranslatorManager *","getTranslator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptTranslatorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","getTranslator", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","getTranslator", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp2);
  result = (Ogre::ScriptTranslator *)(arg1)->getTranslator((Ogre::AbstractNodePtr const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptTranslator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassMaterialTranslator;

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

SWIGINTERN VALUE
_wrap_new_MaterialTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::MaterialTranslator";
  Ogre::MaterialTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::MaterialTranslator *)new Ogre::MaterialTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_MaterialTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::MaterialTranslator *arg1 = (Ogre::MaterialTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__MaterialTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MaterialTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::MaterialTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_MaterialTranslator(Ogre::MaterialTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassTechniqueTranslator;

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

SWIGINTERN VALUE
_wrap_new_TechniqueTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TechniqueTranslator";
  Ogre::TechniqueTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TechniqueTranslator *)new Ogre::TechniqueTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TechniqueTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::TechniqueTranslator *arg1 = (Ogre::TechniqueTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__TechniqueTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TechniqueTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TechniqueTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TechniqueTranslator(Ogre::TechniqueTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassPassTranslator;

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

SWIGINTERN VALUE
_wrap_new_PassTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PassTranslator";
  Ogre::PassTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PassTranslator *)new Ogre::PassTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PassTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::PassTranslator *arg1 = (Ogre::PassTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PassTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PassTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PassTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PassTranslator(Ogre::PassTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassTextureUnitTranslator;

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

SWIGINTERN VALUE
_wrap_new_TextureUnitTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TextureUnitTranslator";
  Ogre::TextureUnitTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TextureUnitTranslator *)new Ogre::TextureUnitTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureUnitTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureUnitTranslator *arg1 = (Ogre::TextureUnitTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__TextureUnitTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureUnitTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureUnitTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextureUnitTranslator(Ogre::TextureUnitTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassTextureSourceTranslator;

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

SWIGINTERN VALUE
_wrap_new_TextureSourceTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TextureSourceTranslator";
  Ogre::TextureSourceTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TextureSourceTranslator *)new Ogre::TextureSourceTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TextureSourceTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::TextureSourceTranslator *arg1 = (Ogre::TextureSourceTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__TextureSourceTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TextureSourceTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TextureSourceTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TextureSourceTranslator(Ogre::TextureSourceTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassGpuProgramTranslator;

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

SWIGINTERN VALUE
_wrap_new_GpuProgramTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::GpuProgramTranslator";
  Ogre::GpuProgramTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::GpuProgramTranslator *)new Ogre::GpuProgramTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::GpuProgramTranslator *arg1 = (Ogre::GpuProgramTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__GpuProgramTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::GpuProgramTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::GpuProgramTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_GpuProgramTranslator_translateProgramParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::ScriptCompiler *arg1 = (Ogre::ScriptCompiler *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > arg2 ;
  Ogre::ObjectAbstractNode *arg3 = (Ogre::ObjectAbstractNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","Ogre::GpuProgramTranslator::translateProgramParameters", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ScriptCompiler * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParametersSharedPtr","Ogre::GpuProgramTranslator::translateProgramParameters", 2, argv[1] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParametersSharedPtr","Ogre::GpuProgramTranslator::translateProgramParameters", 2, argv[1]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::GpuProgramParametersSharedPtr * >(argp2));
    }
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__ObjectAbstractNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::ObjectAbstractNode *","Ogre::GpuProgramTranslator::translateProgramParameters", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::ObjectAbstractNode * >(argp3);
  Ogre::GpuProgramTranslator::translateProgramParameters(arg1,arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_GpuProgramTranslator(Ogre::GpuProgramTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassSharedParamsTranslator;

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

SWIGINTERN VALUE
_wrap_new_SharedParamsTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SharedParamsTranslator";
  Ogre::SharedParamsTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SharedParamsTranslator *)new Ogre::SharedParamsTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SharedParamsTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::SharedParamsTranslator *arg1 = (Ogre::SharedParamsTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__SharedParamsTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SharedParamsTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SharedParamsTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SharedParamsTranslator(Ogre::SharedParamsTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassParticleSystemTranslator;

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

SWIGINTERN VALUE
_wrap_new_ParticleSystemTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ParticleSystemTranslator";
  Ogre::ParticleSystemTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleSystemTranslator *)new Ogre::ParticleSystemTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleSystemTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleSystemTranslator *arg1 = (Ogre::ParticleSystemTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__ParticleSystemTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleSystemTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleSystemTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleSystemTranslator(Ogre::ParticleSystemTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassParticleEmitterTranslator;

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

SWIGINTERN VALUE
_wrap_new_ParticleEmitterTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ParticleEmitterTranslator";
  Ogre::ParticleEmitterTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleEmitterTranslator *)new Ogre::ParticleEmitterTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleEmitterTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleEmitterTranslator *arg1 = (Ogre::ParticleEmitterTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__ParticleEmitterTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleEmitterTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleEmitterTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleEmitterTranslator(Ogre::ParticleEmitterTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassParticleAffectorTranslator;

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

SWIGINTERN VALUE
_wrap_new_ParticleAffectorTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ParticleAffectorTranslator";
  Ogre::ParticleAffectorTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ParticleAffectorTranslator *)new Ogre::ParticleAffectorTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ParticleAffectorTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::ParticleAffectorTranslator *arg1 = (Ogre::ParticleAffectorTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__ParticleAffectorTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ParticleAffectorTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ParticleAffectorTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ParticleAffectorTranslator(Ogre::ParticleAffectorTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassCompositorTranslator;

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

SWIGINTERN VALUE
_wrap_new_CompositorTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CompositorTranslator";
  Ogre::CompositorTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositorTranslator *)new Ogre::CompositorTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositorTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositorTranslator *arg1 = (Ogre::CompositorTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__CompositorTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositorTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositorTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositorTranslator(Ogre::CompositorTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassCompositionTechniqueTranslator;

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

SWIGINTERN VALUE
_wrap_new_CompositionTechniqueTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CompositionTechniqueTranslator";
  Ogre::CompositionTechniqueTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositionTechniqueTranslator *)new Ogre::CompositionTechniqueTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTechniqueTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTechniqueTranslator *arg1 = (Ogre::CompositionTechniqueTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__CompositionTechniqueTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTechniqueTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTechniqueTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTechniqueTranslator(Ogre::CompositionTechniqueTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassCompositionTargetPassTranslator;

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

SWIGINTERN VALUE
_wrap_new_CompositionTargetPassTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CompositionTargetPassTranslator";
  Ogre::CompositionTargetPassTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositionTargetPassTranslator *)new Ogre::CompositionTargetPassTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionTargetPassTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionTargetPassTranslator *arg1 = (Ogre::CompositionTargetPassTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__CompositionTargetPassTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionTargetPassTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionTargetPassTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionTargetPassTranslator(Ogre::CompositionTargetPassTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassCompositionPassTranslator;

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

SWIGINTERN VALUE
_wrap_new_CompositionPassTranslator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::CompositionPassTranslator";
  Ogre::CompositionPassTranslator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::CompositionPassTranslator *)new Ogre::CompositionPassTranslator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_CompositionPassTranslator_translate(int argc, VALUE *argv, VALUE self) {
  Ogre::CompositionPassTranslator *arg1 = (Ogre::CompositionPassTranslator *) 0 ;
  Ogre::ScriptCompiler *arg2 = (Ogre::ScriptCompiler *) 0 ;
  Ogre::AbstractNodePtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__CompositionPassTranslator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::CompositionPassTranslator *","translate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::CompositionPassTranslator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__ScriptCompiler, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ScriptCompiler *","translate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::ScriptCompiler * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","translate", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","translate", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp3);
  (arg1)->translate(arg2,(Ogre::AbstractNodePtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_CompositionPassTranslator(Ogre::CompositionPassTranslator *arg1) {
    delete arg1;
}

swig_class SwigClassBuiltinScriptTranslatorManager;

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

SWIGINTERN VALUE
_wrap_new_BuiltinScriptTranslatorManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::BuiltinScriptTranslatorManager";
  Ogre::BuiltinScriptTranslatorManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::BuiltinScriptTranslatorManager *)new Ogre::BuiltinScriptTranslatorManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BuiltinScriptTranslatorManager_getNumTranslators(int argc, VALUE *argv, VALUE self) {
  Ogre::BuiltinScriptTranslatorManager *arg1 = (Ogre::BuiltinScriptTranslatorManager *) 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_Ogre__BuiltinScriptTranslatorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BuiltinScriptTranslatorManager const *","getNumTranslators", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BuiltinScriptTranslatorManager * >(argp1);
  result = ((Ogre::BuiltinScriptTranslatorManager const *)arg1)->getNumTranslators();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_BuiltinScriptTranslatorManager_getTranslator(int argc, VALUE *argv, VALUE self) {
  Ogre::BuiltinScriptTranslatorManager *arg1 = (Ogre::BuiltinScriptTranslatorManager *) 0 ;
  Ogre::AbstractNodePtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::ScriptTranslator *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_Ogre__BuiltinScriptTranslatorManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::BuiltinScriptTranslatorManager *","getTranslator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::BuiltinScriptTranslatorManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__AbstractNode_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AbstractNodePtr const &","getTranslator", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AbstractNodePtr const &","getTranslator", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AbstractNodePtr * >(argp2);
  result = (Ogre::ScriptTranslator *)(arg1)->getTranslator((Ogre::AbstractNodePtr const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ScriptTranslator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_BuiltinScriptTranslatorManager(Ogre::BuiltinScriptTranslatorManager *arg1) {
    delete arg1;
}

swig_class SwigClassFocusedShadowCameraSetup;

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

SWIGINTERN VALUE
_wrap_new_FocusedShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::FocusedShadowCameraSetup";
  Ogre::FocusedShadowCameraSetup *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::FocusedShadowCameraSetup *)new Ogre::FocusedShadowCameraSetup();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_FocusedShadowCameraSetup(Ogre::FocusedShadowCameraSetup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_FocusedShadowCameraSetup_getShadowCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::FocusedShadowCameraSetup *arg1 = (Ogre::FocusedShadowCameraSetup *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Light *arg5 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg6 = (Ogre::Camera *) 0 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__FocusedShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FocusedShadowCameraSetup const *","getShadowCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FocusedShadowCameraSetup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getShadowCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getShadowCamera", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCamera", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Light * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Camera *","getShadowCamera", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Camera * >(argp6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","getShadowCamera", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ((Ogre::FocusedShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FocusedShadowCameraSetup_setUseAggressiveFocusRegion(int argc, VALUE *argv, VALUE self) {
  Ogre::FocusedShadowCameraSetup *arg1 = (Ogre::FocusedShadowCameraSetup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__FocusedShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FocusedShadowCameraSetup *","setUseAggressiveFocusRegion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FocusedShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseAggressiveFocusRegion", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseAggressiveFocusRegion(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_FocusedShadowCameraSetup_getUseAggressiveFocusRegion(int argc, VALUE *argv, VALUE self) {
  Ogre::FocusedShadowCameraSetup *arg1 = (Ogre::FocusedShadowCameraSetup *) 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_Ogre__FocusedShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::FocusedShadowCameraSetup const *","getUseAggressiveFocusRegion", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::FocusedShadowCameraSetup * >(argp1);
  result = (bool)((Ogre::FocusedShadowCameraSetup const *)arg1)->getUseAggressiveFocusRegion();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassLiSPSMShadowCameraSetup;

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

SWIGINTERN VALUE
_wrap_new_LiSPSMShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::LiSPSMShadowCameraSetup";
  Ogre::LiSPSMShadowCameraSetup *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::LiSPSMShadowCameraSetup *)new Ogre::LiSPSMShadowCameraSetup();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_LiSPSMShadowCameraSetup(Ogre::LiSPSMShadowCameraSetup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_getShadowCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::LiSPSMShadowCameraSetup *arg1 = (Ogre::LiSPSMShadowCameraSetup *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Light *arg5 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg6 = (Ogre::Camera *) 0 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__LiSPSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LiSPSMShadowCameraSetup const *","getShadowCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LiSPSMShadowCameraSetup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getShadowCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getShadowCamera", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCamera", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Light * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Camera *","getShadowCamera", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Camera * >(argp6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","getShadowCamera", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_setOptimalAdjustFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::LiSPSMShadowCameraSetup *arg1 = (Ogre::LiSPSMShadowCameraSetup *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__LiSPSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LiSPSMShadowCameraSetup *","setOptimalAdjustFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LiSPSMShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setOptimalAdjustFactor", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setOptimalAdjustFactor(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_getOptimalAdjustFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::LiSPSMShadowCameraSetup *arg1 = (Ogre::LiSPSMShadowCameraSetup *) 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_Ogre__LiSPSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LiSPSMShadowCameraSetup const *","getOptimalAdjustFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LiSPSMShadowCameraSetup * >(argp1);
  result = (Ogre::Real)((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getOptimalAdjustFactor();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_setUseSimpleOptimalAdjust(int argc, VALUE *argv, VALUE self) {
  Ogre::LiSPSMShadowCameraSetup *arg1 = (Ogre::LiSPSMShadowCameraSetup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__LiSPSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LiSPSMShadowCameraSetup *","setUseSimpleOptimalAdjust", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LiSPSMShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseSimpleOptimalAdjust", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseSimpleOptimalAdjust(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_getUseSimpleOptimalAdjust(int argc, VALUE *argv, VALUE self) {
  Ogre::LiSPSMShadowCameraSetup *arg1 = (Ogre::LiSPSMShadowCameraSetup *) 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_Ogre__LiSPSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LiSPSMShadowCameraSetup const *","getUseSimpleOptimalAdjust", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LiSPSMShadowCameraSetup * >(argp1);
  result = (bool)((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getUseSimpleOptimalAdjust();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_setCameraLightDirectionThreshold(int argc, VALUE *argv, VALUE self) {
  Ogre::LiSPSMShadowCameraSetup *arg1 = (Ogre::LiSPSMShadowCameraSetup *) 0 ;
  Ogre::Degree arg2 ;
  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_Ogre__LiSPSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LiSPSMShadowCameraSetup *","setCameraLightDirectionThreshold", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LiSPSMShadowCameraSetup * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Degree,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Degree","setCameraLightDirectionThreshold", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Degree","setCameraLightDirectionThreshold", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::Degree * >(argp2));
    }
  }
  (arg1)->setCameraLightDirectionThreshold(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_LiSPSMShadowCameraSetup_getCameraLightDirectionThreshold(int argc, VALUE *argv, VALUE self) {
  Ogre::LiSPSMShadowCameraSetup *arg1 = (Ogre::LiSPSMShadowCameraSetup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Degree 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_Ogre__LiSPSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::LiSPSMShadowCameraSetup const *","getCameraLightDirectionThreshold", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::LiSPSMShadowCameraSetup * >(argp1);
  result = ((Ogre::LiSPSMShadowCameraSetup const *)arg1)->getCameraLightDirectionThreshold();
  vresult = SWIG_NewPointerObj((new Ogre::Degree(static_cast< const Ogre::Degree& >(result))), SWIGTYPE_p_Ogre__Degree, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPSSMShadowCameraSetup;

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

SWIGINTERN VALUE
_wrap_new_PSSMShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PSSMShadowCameraSetup";
  Ogre::PSSMShadowCameraSetup *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PSSMShadowCameraSetup *)new Ogre::PSSMShadowCameraSetup();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PSSMShadowCameraSetup(Ogre::PSSMShadowCameraSetup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_calculateSplitPoints__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 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 ;
  
  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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup *","calculateSplitPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","calculateSplitPoints", 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","calculateSplitPoints", 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","calculateSplitPoints", 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","calculateSplitPoints", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->calculateSplitPoints(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_calculateSplitPoints__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 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 ;
  
  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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup *","calculateSplitPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","calculateSplitPoints", 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","calculateSplitPoints", 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","calculateSplitPoints", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->calculateSplitPoints(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PSSMShadowCameraSetup_calculateSplitPoints(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PSSMShadowCameraSetup, 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_PSSMShadowCameraSetup_calculateSplitPoints__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PSSMShadowCameraSetup, 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_PSSMShadowCameraSetup_calculateSplitPoints__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "PSSMShadowCameraSetup.calculateSplitPoints", 
    "    void PSSMShadowCameraSetup.calculateSplitPoints(size_t splitCount, Ogre::Real nearDist, Ogre::Real farDist, Ogre::Real lambda)\n"
    "    void PSSMShadowCameraSetup.calculateSplitPoints(size_t splitCount, Ogre::Real nearDist, Ogre::Real farDist)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_setSplitPoints(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 0 ;
  Ogre::PSSMShadowCameraSetup::SplitPointList *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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup *","setSplitPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup::SplitPointList const &","setSplitPoints", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PSSMShadowCameraSetup::SplitPointList const &","setSplitPoints", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PSSMShadowCameraSetup::SplitPointList * >(argp2);
  (arg1)->setSplitPoints((Ogre::PSSMShadowCameraSetup::SplitPointList const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_setOptimalAdjustFactor(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 0 ;
  size_t arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup *","setOptimalAdjustFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setOptimalAdjustFactor", 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","setOptimalAdjustFactor", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setOptimalAdjustFactor(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_setSplitPadding(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup *","setSplitPadding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSplitPadding", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSplitPadding(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_getSplitPadding(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup const *","getSplitPadding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  result = (Ogre::Real)((Ogre::PSSMShadowCameraSetup const *)arg1)->getSplitPadding();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_getSplitCount(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup const *","getSplitCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  result = ((Ogre::PSSMShadowCameraSetup const *)arg1)->getSplitCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_getShadowCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Light *arg5 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg6 = (Ogre::Camera *) 0 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup const *","getShadowCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getShadowCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getShadowCamera", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCamera", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Light * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Camera *","getShadowCamera", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Camera * >(argp6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","getShadowCamera", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ((Ogre::PSSMShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_getSplitPoints(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PSSMShadowCameraSetup::SplitPointList *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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup const *","getSplitPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  result = (Ogre::PSSMShadowCameraSetup::SplitPointList *) &((Ogre::PSSMShadowCameraSetup const *)arg1)->getSplitPoints();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_getOptimalAdjustFactor__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup const *","getOptimalAdjustFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getOptimalAdjustFactor", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::Real)((Ogre::PSSMShadowCameraSetup const *)arg1)->getOptimalAdjustFactor(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PSSMShadowCameraSetup_getOptimalAdjustFactor__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PSSMShadowCameraSetup *arg1 = (Ogre::PSSMShadowCameraSetup *) 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_Ogre__PSSMShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PSSMShadowCameraSetup const *","getOptimalAdjustFactor", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PSSMShadowCameraSetup * >(argp1);
  result = (Ogre::Real)((Ogre::PSSMShadowCameraSetup const *)arg1)->getOptimalAdjustFactor();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PSSMShadowCameraSetup_getOptimalAdjustFactor(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_Ogre__PSSMShadowCameraSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PSSMShadowCameraSetup_getOptimalAdjustFactor__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PSSMShadowCameraSetup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_size_t(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PSSMShadowCameraSetup_getOptimalAdjustFactor__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PSSMShadowCameraSetup.getOptimalAdjustFactor", 
    "    Ogre::Real PSSMShadowCameraSetup.getOptimalAdjustFactor(size_t splitIndex)\n"
    "    Ogre::Real PSSMShadowCameraSetup.getOptimalAdjustFactor()\n");
  
  return Qnil;
}


swig_class SwigClassPlaneOptimalShadowCameraSetup;

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

SWIGINTERN VALUE
_wrap_new_PlaneOptimalShadowCameraSetup(int argc, VALUE *argv, VALUE self) {
  Ogre::MovablePlane *arg1 = (Ogre::MovablePlane *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PlaneOptimalShadowCameraSetup";
  Ogre::PlaneOptimalShadowCameraSetup *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__MovablePlane, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::MovablePlane *","Ogre::PlaneOptimalShadowCameraSetup", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::MovablePlane * >(argp1);
  result = (Ogre::PlaneOptimalShadowCameraSetup *)new Ogre::PlaneOptimalShadowCameraSetup(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PlaneOptimalShadowCameraSetup(Ogre::PlaneOptimalShadowCameraSetup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PlaneOptimalShadowCameraSetup_getShadowCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PlaneOptimalShadowCameraSetup *arg1 = (Ogre::PlaneOptimalShadowCameraSetup *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::Camera *arg3 = (Ogre::Camera *) 0 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  Ogre::Light *arg5 = (Ogre::Light *) 0 ;
  Ogre::Camera *arg6 = (Ogre::Camera *) 0 ;
  size_t arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  size_t val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__PlaneOptimalShadowCameraSetup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PlaneOptimalShadowCameraSetup const *","getShadowCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PlaneOptimalShadowCameraSetup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager const *","getShadowCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Camera const *","getShadowCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Camera * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport const *","getShadowCamera", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Light, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Light const *","getShadowCamera", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Light * >(argp5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Camera *","getShadowCamera", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Camera * >(argp6);
  ecode7 = SWIG_AsVal_size_t(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "size_t","getShadowCamera", 7, argv[5] ));
  } 
  arg7 = static_cast< size_t >(val7);
  ((Ogre::PlaneOptimalShadowCameraSetup const *)arg1)->getShadowCamera((Ogre::SceneManager const *)arg2,(Ogre::Camera const *)arg3,(Ogre::Viewport const *)arg4,(Ogre::Light const *)arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassShadowVolumeExtrudeProgram;

SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_programNames_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(Ogre::ShadowVolumeExtrudeProgram::programNames), SWIGTYPE_p_std__string,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_frgProgramName_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::ShadowVolumeExtrudeProgram::frgProgramName));
  return _val;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_frgProgramName_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::ShadowVolumeExtrudeProgram::frgProgramName""' of type '""Ogre::String""'"); 
    }
    Ogre::ShadowVolumeExtrudeProgram::frgProgramName = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_initialise(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::ShadowVolumeExtrudeProgram::initialise();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_shutdown(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::ShadowVolumeExtrudeProgram::shutdown();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glsles(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glsles();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glsles(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glsles();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1Debug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1Debug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1Debug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1Debug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0Debug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0Debug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glslesDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glslesDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1Debug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1Debug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1Debug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1Debug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0Debug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0Debug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glslesDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glslesDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getProgramSource(int argc, VALUE *argv, VALUE self) {
  Ogre::Light::LightTypes arg1 ;
  Ogre::String arg2 ;
  bool arg3 ;
  bool arg4 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::Light::LightTypes","Ogre::ShadowVolumeExtrudeProgram::getProgramSource", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Light::LightTypes >(val1);
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), Ruby_Format_TypeError( "", "Ogre::String const","Ogre::ShadowVolumeExtrudeProgram::getProgramSource", 2, argv[1] )); 
    }
    arg2 = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::ShadowVolumeExtrudeProgram::getProgramSource", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","Ogre::ShadowVolumeExtrudeProgram::getProgramSource", 4, argv[3] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getProgramSource(arg1,arg2,arg3,arg4);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getProgramName(int argc, VALUE *argv, VALUE self) {
  Ogre::Light::LightTypes arg1 ;
  bool arg2 ;
  bool arg3 ;
  int val1 ;
  int ecode1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  Ogre::String *result = 0 ;
  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( "", "Ogre::Light::LightTypes","Ogre::ShadowVolumeExtrudeProgram::getProgramName", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Light::LightTypes >(val1);
  ecode2 = SWIG_AsVal_bool(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","Ogre::ShadowVolumeExtrudeProgram::getProgramName", 2, argv[1] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::ShadowVolumeExtrudeProgram::getProgramName", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getProgramName(arg1,arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1Finite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1Finite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1Finite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1Finite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0Finite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0Finite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glslesFinite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glslesFinite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1Finite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1Finite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1Finite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1Finite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0Finite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0Finite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glslesFinite(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glslesFinite();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1FiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderArbvp1FiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1FiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_1_1FiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0FiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_4_0FiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glslesFiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getPointLightExtruderVs_glslesFiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1FiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderArbvp1FiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1FiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_1_1FiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0FiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_4_0FiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glslesFiniteDebug(int argc, VALUE *argv, VALUE self) {
  Ogre::String *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::String *) &Ogre::ShadowVolumeExtrudeProgram::getDirectionalLightExtruderVs_glslesFiniteDebug();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ShadowVolumeExtrudeProgram(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::ShadowVolumeExtrudeProgram";
  Ogre::ShadowVolumeExtrudeProgram *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::ShadowVolumeExtrudeProgram *)new Ogre::ShadowVolumeExtrudeProgram();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_ShadowVolumeExtrudeProgram(Ogre::ShadowVolumeExtrudeProgram *arg1) {
    delete arg1;
}

swig_class SwigClassSkeletonManager;

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

SWIGINTERN VALUE
_wrap_new_SkeletonManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SkeletonManager";
  Ogre::SkeletonManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SkeletonManager *)new Ogre::SkeletonManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SkeletonManager(Ogre::SkeletonManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SkeletonManager_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SkeletonManager *) &Ogre::SkeletonManager::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonManager_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonManager *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SkeletonManager *)Ogre::SkeletonManager::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SkeletonManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassSkeletonSerializer;

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

SWIGINTERN VALUE
_wrap_new_SkeletonSerializer(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SkeletonSerializer";
  Ogre::SkeletonSerializer *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SkeletonSerializer *)new Ogre::SkeletonSerializer();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SkeletonSerializer(Ogre::SkeletonSerializer *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SkeletonSerializer_exportSkeleton__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonSerializer *arg1 = (Ogre::SkeletonSerializer *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::SkeletonVersion arg4 ;
  Ogre::Serializer::Endian arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SkeletonSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonSerializer *","exportSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","exportSkeleton", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  {
    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 &","exportSkeleton", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportSkeleton", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SkeletonVersion","exportSkeleton", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SkeletonVersion >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportSkeleton", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Serializer::Endian >(val5);
  (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,(Ogre::String const &)*arg3,arg4,arg5);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_exportSkeleton__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonSerializer *arg1 = (Ogre::SkeletonSerializer *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::SkeletonVersion arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SkeletonSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonSerializer *","exportSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","exportSkeleton", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  {
    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 &","exportSkeleton", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportSkeleton", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SkeletonVersion","exportSkeleton", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SkeletonVersion >(val4);
  (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,(Ogre::String const &)*arg3,arg4);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_exportSkeleton__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonSerializer *arg1 = (Ogre::SkeletonSerializer *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SkeletonSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonSerializer *","exportSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","exportSkeleton", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  {
    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 &","exportSkeleton", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exportSkeleton", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_exportSkeleton__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonSerializer *arg1 = (Ogre::SkeletonSerializer *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  Ogre::SkeletonVersion arg4 ;
  Ogre::Serializer::Endian arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__SkeletonSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonSerializer *","exportSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","exportSkeleton", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportSkeleton", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportSkeleton", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SkeletonVersion","exportSkeleton", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SkeletonVersion >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Serializer::Endian","exportSkeleton", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Serializer::Endian >(val5);
  (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_exportSkeleton__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonSerializer *arg1 = (Ogre::SkeletonSerializer *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  Ogre::SkeletonVersion arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__SkeletonSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonSerializer *","exportSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","exportSkeleton", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportSkeleton", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportSkeleton", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::SkeletonVersion","exportSkeleton", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::SkeletonVersion >(val4);
  (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_exportSkeleton__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonSerializer *arg1 = (Ogre::SkeletonSerializer *) 0 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__SkeletonSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonSerializer *","exportSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton const *","exportSkeleton", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  {
    res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
    if (!SWIG_IsOK(res3)) {
      SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr","exportSkeleton", 3, argv[1] )); 
    }  
    if (!argp3) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr","exportSkeleton", 3, argv[1]));
    } else {
      arg3 = *(reinterpret_cast< Ogre::DataStreamPtr * >(argp3));
    }
  }
  (arg1)->exportSkeleton((Ogre::Skeleton const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SkeletonSerializer_exportSkeleton(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_Ogre__SkeletonSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_SkeletonSerializer_exportSkeleton__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 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_SkeletonSerializer_exportSkeleton__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SkeletonSerializer_exportSkeleton__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_SkeletonSerializer_exportSkeleton__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _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_SkeletonSerializer_exportSkeleton__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SkeletonSerializer, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Skeleton, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _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_SkeletonSerializer_exportSkeleton__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "SkeletonSerializer.exportSkeleton", 
    "    void SkeletonSerializer.exportSkeleton(Ogre::Skeleton const *pSkeleton, Ogre::String const &filename, Ogre::SkeletonVersion ver, Ogre::Serializer::Endian endianMode)\n"
    "    void SkeletonSerializer.exportSkeleton(Ogre::Skeleton const *pSkeleton, Ogre::String const &filename, Ogre::SkeletonVersion ver)\n"
    "    void SkeletonSerializer.exportSkeleton(Ogre::Skeleton const *pSkeleton, Ogre::String const &filename)\n"
    "    void SkeletonSerializer.exportSkeleton(Ogre::Skeleton const *pSkeleton, Ogre::DataStreamPtr stream, Ogre::SkeletonVersion ver, Ogre::Serializer::Endian endianMode)\n"
    "    void SkeletonSerializer.exportSkeleton(Ogre::Skeleton const *pSkeleton, Ogre::DataStreamPtr stream, Ogre::SkeletonVersion ver)\n"
    "    void SkeletonSerializer.exportSkeleton(Ogre::Skeleton const *pSkeleton, Ogre::DataStreamPtr stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SkeletonSerializer_importSkeleton(int argc, VALUE *argv, VALUE self) {
  Ogre::SkeletonSerializer *arg1 = (Ogre::SkeletonSerializer *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::Skeleton *arg3 = (Ogre::Skeleton *) 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_Ogre__SkeletonSerializer, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SkeletonSerializer *","importSkeleton", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SkeletonSerializer * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","importSkeleton", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","importSkeleton", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Skeleton *","importSkeleton", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Skeleton * >(argp3);
  (arg1)->importSkeleton(*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SPOT_SHADOW_FADE_PNG_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(Ogre::SPOT_SHADOW_FADE_PNG), SWIGTYPE_p_unsigned_char,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_SPOT_SHADOW_FADE_PNG_set(VALUE self, VALUE _val) {
  {
    unsigned char *inp = 0;
    int res = SWIG_ConvertPtr(_val, SWIG_as_voidptrptr(&inp), SWIGTYPE_p_unsigned_char,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::SPOT_SHADOW_FADE_PNG""' of type '""unsigned char [9728]""'");
    } else if (inp) {
      size_t ii = 0;
      for (; ii < (size_t)9728; ++ii) Ogre::SPOT_SHADOW_FADE_PNG[ii] = inp[ii];
    } else {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Ogre::SPOT_SHADOW_FADE_PNG""' of type '""unsigned char [9728]""'");
    }
  }
  return _val;
fail:
  return Qnil;
}


swig_class SwigClassStaticFaceGroup;

SWIGINTERN VALUE
_wrap_StaticFaceGroup_fType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  Ogre::FaceGroupType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","fType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::FaceGroupType","fType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::FaceGroupType >(val2);
  if (arg1) (arg1)->fType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_fType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::FaceGroupType 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","fType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (Ogre::FaceGroupType) ((arg1)->fType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_isSky_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","isSky", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","isSky", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->isSky = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_isSky_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","isSky", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (bool) ((arg1)->isSky);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_vertexStart_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","vertexStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","vertexStart", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->vertexStart = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_vertexStart_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","vertexStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (int) ((arg1)->vertexStart);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_numVertices_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","numVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","numVertices", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->numVertices = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_numVertices_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","numVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (int) ((arg1)->numVertices);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_elementStart_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","elementStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","elementStart", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->elementStart = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_elementStart_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","elementStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (int) ((arg1)->elementStart);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_numElements_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","numElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","numElements", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->numElements = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_numElements_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","numElements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (int) ((arg1)->numElements);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_materialHandle_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","materialHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","materialHandle", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  if (arg1) (arg1)->materialHandle = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_materialHandle_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","materialHandle", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (int) ((arg1)->materialHandle);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_plane_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  Ogre::Plane *arg2 = (Ogre::Plane *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","plane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane *","plane", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  if (arg1) (arg1)->plane = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_plane_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Plane *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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","plane", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (Ogre::Plane *)& ((arg1)->plane);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_patchSurf_set(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  Ogre::PatchSurface *arg2 = (Ogre::PatchSurface *) 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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","patchSurf", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PatchSurface, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PatchSurface *","patchSurf", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PatchSurface * >(argp2);
  if (arg1) (arg1)->patchSurf = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticFaceGroup_patchSurf_get(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticFaceGroup *arg1 = (Ogre::StaticFaceGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PatchSurface *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_Ogre__StaticFaceGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticFaceGroup *","patchSurf", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticFaceGroup * >(argp1);
  result = (Ogre::PatchSurface *) ((arg1)->patchSurf);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PatchSurface, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_StaticFaceGroup(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::StaticFaceGroup";
  Ogre::StaticFaceGroup *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::StaticFaceGroup *)new Ogre::StaticFaceGroup();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StaticFaceGroup(Ogre::StaticFaceGroup *arg1) {
    delete arg1;
}

swig_class SwigClassStaticGeometry;

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

SWIGINTERN VALUE
_wrap_new_StaticGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::StaticGeometry";
  Ogre::StaticGeometry *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::StaticGeometry", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::StaticGeometry", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StaticGeometry", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::StaticGeometry *)new Ogre::StaticGeometry(arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN void
free_Ogre_StaticGeometry(Ogre::StaticGeometry *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_StaticGeometry_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (Ogre::String *) &((Ogre::StaticGeometry const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_addEntity__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","addEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","addEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(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 &","addEntity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","addEntity", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","addEntity", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 const &","addEntity", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4,(Ogre::Vector3 const &)*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_addEntity__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Quaternion *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","addEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","addEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(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 &","addEntity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__Quaternion,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Quaternion const &","addEntity", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Quaternion const &","addEntity", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Quaternion * >(argp4);
  (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3,(Ogre::Quaternion const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_addEntity__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","addEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","addEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(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 &","addEntity", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","addEntity", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->addEntity(arg2,(Ogre::Vector3 const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StaticGeometry_addEntity(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_Ogre__StaticGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 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_StaticGeometry_addEntity__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StaticGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 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__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StaticGeometry_addEntity__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StaticGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Entity, 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__Quaternion, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_StaticGeometry_addEntity__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "StaticGeometry.addEntity", 
    "    void StaticGeometry.addEntity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation, Ogre::Vector3 const &scale)\n"
    "    void StaticGeometry.addEntity(Ogre::Entity *ent, Ogre::Vector3 const &position, Ogre::Quaternion const &orientation)\n"
    "    void StaticGeometry.addEntity(Ogre::Entity *ent, Ogre::Vector3 const &position)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_addSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::SceneNode *arg2 = (Ogre::SceneNode *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","addSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneNode const *","addSceneNode", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneNode * >(argp2);
  (arg1)->addSceneNode((Ogre::SceneNode const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_build(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  (arg1)->build();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_destroy(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","destroy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  (arg1)->destroy();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_reset(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","reset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  (arg1)->reset();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_setRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","setRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setRenderingDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setRenderingDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","getRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (Ogre::Real)((Ogre::StaticGeometry const *)arg1)->getRenderingDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getSquaredRenderingDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","getSquaredRenderingDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (Ogre::Real)((Ogre::StaticGeometry const *)arg1)->getSquaredRenderingDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_setVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (bool)((Ogre::StaticGeometry const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_setCastShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","setCastShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCastShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCastShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getCastShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","getCastShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (bool)(arg1)->getCastShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_setRegionDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Vector3 *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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","setRegionDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(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 &","setRegionDimensions", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setRegionDimensions", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setRegionDimensions((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getRegionDimensions(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","getRegionDimensions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::StaticGeometry const *)arg1)->getRegionDimensions();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_setOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Vector3 *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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","setOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(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 &","setOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::StaticGeometry const *)arg1)->getOrigin();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_setVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::uint32 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","setVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setVisibilityFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setVisibilityFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","getVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (Ogre::uint32)((Ogre::StaticGeometry const *)arg1)->getVisibilityFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","getRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (Ogre::uint8)((Ogre::StaticGeometry const *)arg1)->getRenderQueueGroup();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_visitRenderables__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","visitRenderables", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->visitRenderables(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_visitRenderables__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::Renderable::Visitor *arg2 = (Ogre::Renderable::Visitor *) 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","visitRenderables", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Renderable__Visitor, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Renderable::Visitor *","visitRenderables", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Renderable::Visitor * >(argp2);
  (arg1)->visitRenderables(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StaticGeometry_visitRenderables(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_Ogre__StaticGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StaticGeometry_visitRenderables__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StaticGeometry, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Renderable__Visitor, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StaticGeometry_visitRenderables__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StaticGeometry.visitRenderables", 
    "    void StaticGeometry.visitRenderables(Ogre::Renderable::Visitor *visitor, bool debugRenderables)\n"
    "    void StaticGeometry.visitRenderables(Ogre::Renderable::Visitor *visitor)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_getRegionIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::uint32,Ogre::Region *,std::less< Ogre::uint32 >,Ogre::STLAllocator< std::pair< Ogre::uint32 const,Ogre::Region * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry *","getRegionIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(argp1);
  result = (arg1)->getRegionIterator();
  vresult = SWIG_NewPointerObj((new Ogre::StaticGeometry::RegionIterator(static_cast< const Ogre::StaticGeometry::RegionIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticGeometry_dump(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticGeometry *arg1 = (Ogre::StaticGeometry *) 0 ;
  Ogre::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_Ogre__StaticGeometry, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticGeometry const *","dump", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticGeometry * >(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( "", "Ogre::String const &","dump", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","dump", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ((Ogre::StaticGeometry const *)arg1)->dump((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassStaticPluginLoader;

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

SWIGINTERN VALUE
_wrap_new_StaticPluginLoader(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::StaticPluginLoader";
  Ogre::StaticPluginLoader *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::StaticPluginLoader *)new Ogre::StaticPluginLoader();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticPluginLoader_load(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticPluginLoader *arg1 = (Ogre::StaticPluginLoader *) 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_Ogre__StaticPluginLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticPluginLoader *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticPluginLoader * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StaticPluginLoader_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::StaticPluginLoader *arg1 = (Ogre::StaticPluginLoader *) 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_Ogre__StaticPluginLoader, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StaticPluginLoader *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StaticPluginLoader * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_StaticPluginLoader(Ogre::StaticPluginLoader *arg1) {
    delete arg1;
}

swig_class SwigClassStreamSerialiser;

SWIGINTERN VALUE
_wrap_new_StreamSerialiser__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  Ogre::StreamSerialiser::Endian arg2 ;
  bool arg3 ;
  Ogre::StreamSerialiser::RealStorageFormat arg4 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::StreamSerialiser";
  Ogre::StreamSerialiser *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser::Endian","Ogre::StreamSerialiser", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::StreamSerialiser::Endian >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::StreamSerialiser", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_int(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser::RealStorageFormat","Ogre::StreamSerialiser", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::StreamSerialiser::RealStorageFormat >(val4);
  result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_StreamSerialiser__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  Ogre::StreamSerialiser::Endian arg2 ;
  bool arg3 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::StreamSerialiser";
  Ogre::StreamSerialiser *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser::Endian","Ogre::StreamSerialiser", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::StreamSerialiser::Endian >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::StreamSerialiser", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_StreamSerialiser__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  Ogre::StreamSerialiser::Endian arg2 ;
  void *argp1 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::StreamSerialiser";
  Ogre::StreamSerialiser *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__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser::Endian","Ogre::StreamSerialiser", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::StreamSerialiser::Endian >(val2);
  result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_StreamSerialiser__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::DataStreamPtr *arg1 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::StreamSerialiser";
  Ogre::StreamSerialiser *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__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","Ogre::StreamSerialiser", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::DataStreamPtr * >(argp1);
  result = (Ogre::StreamSerialiser *)new Ogre::StreamSerialiser((Ogre::DataStreamPtr const &)*arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_StreamSerialiser(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_StreamSerialiser__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_StreamSerialiser__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_new_StreamSerialiser__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(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_StreamSerialiser__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StreamSerialiser.new", 
    "    StreamSerialiser.new(Ogre::DataStreamPtr const &stream, Ogre::StreamSerialiser::Endian endianMode, bool autoHeader, Ogre::StreamSerialiser::RealStorageFormat realFormat)\n"
    "    StreamSerialiser.new(Ogre::DataStreamPtr const &stream, Ogre::StreamSerialiser::Endian endianMode, bool autoHeader)\n"
    "    StreamSerialiser.new(Ogre::DataStreamPtr const &stream, Ogre::StreamSerialiser::Endian endianMode)\n"
    "    StreamSerialiser.new(Ogre::DataStreamPtr const &stream)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_StreamSerialiser(Ogre::StreamSerialiser *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_StreamSerialiser_getEndian(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StreamSerialiser::Endian 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser const *","getEndian", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = (Ogre::StreamSerialiser::Endian)((Ogre::StreamSerialiser const *)arg1)->getEndian();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_makeIdentifier(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  Ogre::uint32 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( "", "Ogre::String const &","Ogre::StreamSerialiser::makeIdentifier", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::StreamSerialiser::makeIdentifier", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::uint32)Ogre::StreamSerialiser::makeIdentifier((std::string const &)*arg1);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  if (SWIG_IsNewObj(res1)) delete arg1;
  return vresult;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_getCurrentChunkDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser const *","getCurrentChunkDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = ((Ogre::StreamSerialiser const *)arg1)->getCurrentChunkDepth();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_getCurrentChunkID(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser const *","getCurrentChunkID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = (Ogre::uint32)((Ogre::StreamSerialiser const *)arg1)->getCurrentChunkID();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_getOffsetFromChunkStart(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser const *","getOffsetFromChunkStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = ((Ogre::StreamSerialiser const *)arg1)->getOffsetFromChunkStart();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_readChunkBegin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StreamSerialiser::Chunk *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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","readChunkBegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = (Ogre::StreamSerialiser::Chunk *)(arg1)->readChunkBegin();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser__Chunk, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_readChunkBegin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::StreamSerialiser::Chunk *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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","readChunkBegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","readChunkBegin", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","readChunkBegin", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","readChunkBegin", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","readChunkBegin", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::StreamSerialiser::Chunk *)(arg1)->readChunkBegin(arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser__Chunk, 0 |  0 );
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_readChunkBegin__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::StreamSerialiser::Chunk *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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","readChunkBegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","readChunkBegin", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","readChunkBegin", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  result = (Ogre::StreamSerialiser::Chunk *)(arg1)->readChunkBegin(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser__Chunk, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StreamSerialiser_readChunkBegin(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_StreamSerialiser_readChunkBegin__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_readChunkBegin__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_StreamSerialiser_readChunkBegin__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "StreamSerialiser.readChunkBegin", 
    "    Ogre::StreamSerialiser::Chunk const * StreamSerialiser.readChunkBegin()\n"
    "    Ogre::StreamSerialiser::Chunk const * StreamSerialiser.readChunkBegin(Ogre::uint32 id, Ogre::uint16 maxVersion, Ogre::String const &msg)\n"
    "    Ogre::StreamSerialiser::Chunk const * StreamSerialiser.readChunkBegin(Ogre::uint32 id, Ogre::uint16 maxVersion)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_undoReadChunk(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","undoReadChunk", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","undoReadChunk", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->undoReadChunk(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_peekNextChunkID(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","peekNextChunkID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = (Ogre::uint32)(arg1)->peekNextChunkID();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_readChunkEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","readChunkEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","readChunkEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->readChunkEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_isEndOfChunk(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","isEndOfChunk", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","isEndOfChunk", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  result = (bool)(arg1)->isEndOfChunk(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_eof(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser const *","eof", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = (bool)((Ogre::StreamSerialiser const *)arg1)->eof();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_getCurrentChunk(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::StreamSerialiser::Chunk *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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser const *","getCurrentChunk", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  result = (Ogre::StreamSerialiser::Chunk *)((Ogre::StreamSerialiser const *)arg1)->getCurrentChunk();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser__Chunk, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_writeChunkBegin__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 arg2 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","writeChunkBegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","writeChunkBegin", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","writeChunkBegin", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  (arg1)->writeChunkBegin(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_writeChunkBegin__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","writeChunkBegin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","writeChunkBegin", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->writeChunkBegin(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StreamSerialiser_writeChunkBegin(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_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_StreamSerialiser_writeChunkBegin__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_writeChunkBegin__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StreamSerialiser.writeChunkBegin", 
    "    void StreamSerialiser.writeChunkBegin(Ogre::uint32 id, Ogre::uint16 version)\n"
    "    void StreamSerialiser.writeChunkBegin(Ogre::uint32 id)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_writeChunkEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::uint32 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","writeChunkEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","writeChunkEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->writeChunkEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_writeData(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","writeData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void const *","writeData", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","writeData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","writeData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->writeData((void const *)arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Real *arg2 = (Ogre::Real *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Real const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Real *arg2 = (Ogre::Real *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  (arg1)->write((Ogre::Real const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector2 *arg2 = (Ogre::Vector2 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Vector2 const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector2 *arg2 = (Ogre::Vector2 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->write((Ogre::Vector2 const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Vector3 const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->write((Ogre::Vector3 const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector4 *arg2 = (Ogre::Vector4 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Vector4 const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector4 *arg2 = (Ogre::Vector4 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  (arg1)->write((Ogre::Vector4 const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Quaternion *arg2 = (Ogre::Quaternion *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Quaternion const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Quaternion *arg2 = (Ogre::Quaternion *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->write((Ogre::Quaternion const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix3 *arg2 = (Ogre::Matrix3 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Matrix3 const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_13(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix3 *arg2 = (Ogre::Matrix3 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  (arg1)->write((Ogre::Matrix3 const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_14(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Matrix4 const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_15(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->write((Ogre::Matrix4 const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_16(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::String *arg2 = (Ogre::String *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  (arg1)->write((Ogre::String const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_17(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::AxisAlignedBox *arg2 = (Ogre::AxisAlignedBox *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::AxisAlignedBox const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_18(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::AxisAlignedBox *arg2 = (Ogre::AxisAlignedBox *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->write((Ogre::AxisAlignedBox const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_19(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Sphere *arg2 = (Ogre::Sphere *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Sphere const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_20(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Sphere *arg2 = (Ogre::Sphere *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  (arg1)->write((Ogre::Sphere const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_21(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Plane *arg2 = (Ogre::Plane *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Plane const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_22(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Plane *arg2 = (Ogre::Plane *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  (arg1)->write((Ogre::Plane const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_23(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Ray *arg2 = (Ogre::Ray *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Ray const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_24(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Ray *arg2 = (Ogre::Ray *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  (arg1)->write((Ogre::Ray const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_25(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Radian *arg2 = (Ogre::Radian *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Radian const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_26(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Radian *arg2 = (Ogre::Radian *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->write((Ogre::Radian const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_27(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((Ogre::Node const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_28(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->write((Ogre::Node const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_29(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  bool *arg2 = (bool *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","write", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->write((bool const *)arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_write__SWIG_30(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  bool *arg2 = (bool *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","write", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool const *","write", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  (arg1)->write((bool const *)arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StreamSerialiser_write(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_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_StreamSerialiser_write__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_StreamSerialiser_write__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_9(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_11(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_13(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_15(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_18(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_20(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_22(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_24(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_26(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_28(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_write__SWIG_30(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_StreamSerialiser_write__SWIG_16(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_17(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_10(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_19(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_21(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_12(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_23(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_25(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_14(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_27(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_8(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_29(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_write__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StreamSerialiser.write", 
    "    void StreamSerialiser.write(Ogre::Real const *val, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Real const *val)\n"
    "    void StreamSerialiser.write(Ogre::Vector2 const *vec, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Vector2 const *vec)\n"
    "    void StreamSerialiser.write(Ogre::Vector3 const *vec, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Vector3 const *vec)\n"
    "    void StreamSerialiser.write(Ogre::Vector4 const *vec, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Vector4 const *vec)\n"
    "    void StreamSerialiser.write(Ogre::Quaternion const *q, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Quaternion const *q)\n"
    "    void StreamSerialiser.write(Ogre::Matrix3 const *m, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Matrix3 const *m)\n"
    "    void StreamSerialiser.write(Ogre::Matrix4 const *m, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Matrix4 const *m)\n"
    "    void StreamSerialiser.write(Ogre::String const *string)\n"
    "    void StreamSerialiser.write(Ogre::AxisAlignedBox const *aabb, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::AxisAlignedBox const *aabb)\n"
    "    void StreamSerialiser.write(Ogre::Sphere const *sphere, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Sphere const *sphere)\n"
    "    void StreamSerialiser.write(Ogre::Plane const *plane, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Plane const *plane)\n"
    "    void StreamSerialiser.write(Ogre::Ray const *ray, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Ray const *ray)\n"
    "    void StreamSerialiser.write(Ogre::Radian const *angle, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Radian const *angle)\n"
    "    void StreamSerialiser.write(Ogre::Node const *node, size_t count)\n"
    "    void StreamSerialiser.write(Ogre::Node const *node)\n"
    "    void StreamSerialiser.write(bool const *boolean, size_t count)\n"
    "    void StreamSerialiser.write(bool const *boolean)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_readData(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  void *arg2 = (void *) 0 ;
  size_t arg3 ;
  size_t arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 ;
  size_t val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","readData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0],SWIG_as_voidptrptr(&arg2), 0, 0);
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "void *","readData", 2, argv[0] )); 
  }
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","readData", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","readData", 4, argv[2] ));
  } 
  arg4 = static_cast< size_t >(val4);
  (arg1)->readData(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Real *arg2 = (Ogre::Real *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Real *arg2 = (Ogre::Real *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Real *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Real * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector2 *arg2 = (Ogre::Vector2 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector2 *arg2 = (Ogre::Vector2 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector2 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector3 *arg2 = (Ogre::Vector3 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector3 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_8(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector4 *arg2 = (Ogre::Vector4 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_9(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Vector4 *arg2 = (Ogre::Vector4 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Vector4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Vector4 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Vector4 * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_10(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Quaternion *arg2 = (Ogre::Quaternion *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_11(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Quaternion *arg2 = (Ogre::Quaternion *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Quaternion, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Quaternion *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Quaternion * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_12(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix3 *arg2 = (Ogre::Matrix3 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_13(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix3 *arg2 = (Ogre::Matrix3 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix3, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix3 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix3 * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_14(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_15(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_16(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::String *arg2 = (Ogre::String *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_std__string, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::String * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_17(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::AxisAlignedBox *arg2 = (Ogre::AxisAlignedBox *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_18(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::AxisAlignedBox *arg2 = (Ogre::AxisAlignedBox *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_19(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Sphere *arg2 = (Ogre::Sphere *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_20(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Sphere *arg2 = (Ogre::Sphere *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Sphere, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_21(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Plane *arg2 = (Ogre::Plane *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_22(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Plane *arg2 = (Ogre::Plane *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Plane, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Plane *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Plane * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_23(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Ray *arg2 = (Ogre::Ray *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_24(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Ray *arg2 = (Ogre::Ray *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Ray, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_25(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Radian *arg2 = (Ogre::Radian *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_26(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Radian *arg2 = (Ogre::Radian *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Radian, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Radian *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Radian * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_27(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_28(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  Ogre::Node *arg2 = (Ogre::Node *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Node, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Node *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Node * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_29(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  bool *arg2 = (bool *) 0 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","read", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  (arg1)->read(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_StreamSerialiser_read__SWIG_30(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = (Ogre::StreamSerialiser *) 0 ;
  bool *arg2 = (bool *) 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_Ogre__StreamSerialiser, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser *","read", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_bool, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "bool *","read", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< bool * >(argp2);
  (arg1)->read(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_StreamSerialiser_read(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_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_StreamSerialiser_read__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_StreamSerialiser_read__SWIG_7(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_9(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_11(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_13(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_15(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_18(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_20(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_22(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_24(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_26(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_28(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_StreamSerialiser_read__SWIG_30(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_StreamSerialiser_read__SWIG_16(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__AxisAlignedBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_17(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Quaternion, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_10(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Sphere, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_19(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_6(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Plane, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_21(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix3, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_12(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_23(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 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_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Radian, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_25(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Matrix4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_14(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Node, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_27(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Vector4, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_8(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_bool, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_29(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_float, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_size_t(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_StreamSerialiser_read__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "StreamSerialiser.read", 
    "    void StreamSerialiser.read(Ogre::Real *val, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Real *val)\n"
    "    void StreamSerialiser.read(Ogre::Vector2 *vec, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Vector2 *vec)\n"
    "    void StreamSerialiser.read(Ogre::Vector3 *vec, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Vector3 *vec)\n"
    "    void StreamSerialiser.read(Ogre::Vector4 *vec, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Vector4 *vec)\n"
    "    void StreamSerialiser.read(Ogre::Quaternion *q, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Quaternion *q)\n"
    "    void StreamSerialiser.read(Ogre::Matrix3 *m, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Matrix3 *m)\n"
    "    void StreamSerialiser.read(Ogre::Matrix4 *m, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Matrix4 *m)\n"
    "    void StreamSerialiser.read(Ogre::String *string)\n"
    "    void StreamSerialiser.read(Ogre::AxisAlignedBox *aabb, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::AxisAlignedBox *aabb)\n"
    "    void StreamSerialiser.read(Ogre::Sphere *sphere, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Sphere *sphere)\n"
    "    void StreamSerialiser.read(Ogre::Plane *plane, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Plane *plane)\n"
    "    void StreamSerialiser.read(Ogre::Ray *ray, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Ray *ray)\n"
    "    void StreamSerialiser.read(Ogre::Radian *angle, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Radian *angle)\n"
    "    void StreamSerialiser.read(Ogre::Node *node, size_t count)\n"
    "    void StreamSerialiser.read(Ogre::Node *node)\n"
    "    void StreamSerialiser.read(bool *val, size_t count)\n"
    "    void StreamSerialiser.read(bool *val)\n");
  
  return Qnil;
}


swig_class SwigClassSubEntity;

SWIGINTERN VALUE
_wrap_SubEntity_getMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::String *) &((Ogre::SubEntity const *)arg1)->getMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_setMaterialName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_setMaterialName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SubEntity_setMaterialName(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_Ogre__SubEntity, 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_SubEntity_setMaterialName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SubEntity, 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_SubEntity_setMaterialName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SubEntity.setMaterialName", 
    "    void SubEntity.setMaterialName(Ogre::String const &name, Ogre::String const &groupName)\n"
    "    void SubEntity.setMaterialName(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_setMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::MaterialPtr *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","setMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","setMaterial", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  (arg1)->setMaterial((Ogre::MaterialPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_setVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","setVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setVisible", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setVisible(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_isVisible(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","isVisible", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (bool)((Ogre::SubEntity const *)arg1)->isVisible();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_setRenderQueueGroupAndPriority(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","setRenderQueueGroupAndPriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroupAndPriority", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","setRenderQueueGroupAndPriority", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->setRenderQueueGroupAndPriority(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::uint8)((Ogre::SubEntity const *)arg1)->getRenderQueueGroup();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getRenderQueuePriority(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ushort 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getRenderQueuePriority", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::ushort)((Ogre::SubEntity const *)arg1)->getRenderQueuePriority();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_isRenderQueueGroupSet(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","isRenderQueueGroupSet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (bool)((Ogre::SubEntity const *)arg1)->isRenderQueueGroupSet();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_isRenderQueuePrioritySet(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","isRenderQueuePrioritySet", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (bool)((Ogre::SubEntity const *)arg1)->isRenderQueuePrioritySet();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getSubMesh(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SubMesh *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","getSubMesh", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::SubMesh *)(arg1)->getSubMesh();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SubMesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Entity *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::Entity *)((Ogre::SubEntity const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::SubEntity const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getTechnique(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Technique *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getTechnique", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::Technique *)((Ogre::SubEntity const *)arg1)->getTechnique();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Technique, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getRenderOperation(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::RenderOperation *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getWorldTransforms", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::SubEntity const *)arg1)->getWorldTransforms(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getNumWorldTransforms(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getNumWorldTransforms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (unsigned short)((Ogre::SubEntity const *)arg1)->getNumWorldTransforms();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::SubEntity const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::LightList *) &((Ogre::SubEntity const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getCastsShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","getCastsShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (bool)((Ogre::SubEntity const *)arg1)->getCastsShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__getSkelAnimVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_getSkelAnimVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::VertexData *)(arg1)->_getSkelAnimVertexData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__getSoftwareVertexAnimVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_getSoftwareVertexAnimVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::VertexData *)(arg1)->_getSoftwareVertexAnimVertexData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__getHardwareVertexAnimVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_getHardwareVertexAnimVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::VertexData *)(arg1)->_getHardwareVertexAnimVertexData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__getSkelAnimTempBufferInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TempBlendedBufferInfo *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_getSkelAnimTempBufferInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getSkelAnimTempBufferInfo();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__getVertexAnimTempBufferInfo(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TempBlendedBufferInfo *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_getVertexAnimTempBufferInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::TempBlendedBufferInfo *)(arg1)->_getVertexAnimTempBufferInfo();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TempBlendedBufferInfo, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity_getVertexDataForBinding(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","getVertexDataForBinding", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (Ogre::VertexData *)(arg1)->getVertexDataForBinding();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__markBuffersUnusedForAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_markBuffersUnusedForAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  (arg1)->_markBuffersUnusedForAnimation();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__markBuffersUsedForAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_markBuffersUsedForAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  (arg1)->_markBuffersUsedForAnimation();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__getBuffersMarkedForAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","_getBuffersMarkedForAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  result = (bool)((Ogre::SubEntity const *)arg1)->_getBuffersMarkedForAnimation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__restoreBuffersForUnusedAnimation(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_restoreBuffersForUnusedAnimation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_restoreBuffersForUnusedAnimation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_restoreBuffersForUnusedAnimation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__updateCustomGpuParameter(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 0 ;
  Ogre::GpuProgramParameters::AutoConstantEntry *arg2 = 0 ;
  Ogre::GpuProgramParameters *arg3 = (Ogre::GpuProgramParameters *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity const *","_updateCustomGpuParameter", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__GpuProgramParameters__AutoConstantEntry,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters::AutoConstantEntry const &","_updateCustomGpuParameter", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::GpuProgramParameters::AutoConstantEntry const &","_updateCustomGpuParameter", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::GpuProgramParameters::AutoConstantEntry * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__GpuProgramParameters, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::GpuProgramParameters *","_updateCustomGpuParameter", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::GpuProgramParameters * >(argp3);
  ((Ogre::SubEntity const *)arg1)->_updateCustomGpuParameter((Ogre::GpuProgramParameters::AutoConstantEntry const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubEntity__invalidateCameraCache(int argc, VALUE *argv, VALUE self) {
  Ogre::SubEntity *arg1 = (Ogre::SubEntity *) 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_Ogre__SubEntity, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubEntity *","_invalidateCameraCache", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubEntity * >(argp1);
  (arg1)->_invalidateCameraCache();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassSubMesh;

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

SWIGINTERN VALUE
_wrap_new_SubMesh(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SubMesh";
  Ogre::SubMesh *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SubMesh *)new Ogre::SubMesh();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SubMesh(Ogre::SubMesh *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SubMesh_useSharedVertices_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","useSharedVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","useSharedVertices", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  if (arg1) (arg1)->useSharedVertices = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_useSharedVertices_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","useSharedVertices", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (bool) ((arg1)->useSharedVertices);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_operationType_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::RenderOperation::OperationType arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","operationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::RenderOperation::OperationType","operationType", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::RenderOperation::OperationType >(val2);
  if (arg1) (arg1)->operationType = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_operationType_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::RenderOperation::OperationType 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","operationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::RenderOperation::OperationType) ((arg1)->operationType);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_vertexData_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","vertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","vertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  if (arg1) (arg1)->vertexData = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_vertexData_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexData *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","vertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::VertexData *) ((arg1)->vertexData);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_indexData_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::IndexData *arg2 = (Ogre::IndexData *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","indexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IndexData, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IndexData *","indexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IndexData * >(argp2);
  if (arg1) (arg1)->indexData = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_indexData_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::IndexData *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","indexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::IndexData *) ((arg1)->indexData);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_blendIndexToBoneIndexMap_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::SubMesh::IndexMap *arg2 = (Ogre::SubMesh::IndexMap *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","blendIndexToBoneIndexMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh::IndexMap *","blendIndexToBoneIndexMap", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh::IndexMap * >(argp2);
  if (arg1) (arg1)->blendIndexToBoneIndexMap = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_blendIndexToBoneIndexMap_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SubMesh::IndexMap *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","blendIndexToBoneIndexMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::SubMesh::IndexMap *)& ((arg1)->blendIndexToBoneIndexMap);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_mLodFaceList_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::SubMesh::LODFaceList *arg2 = (Ogre::SubMesh::LODFaceList *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","mLodFaceList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SubMesh::LODFaceList *","mLodFaceList", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SubMesh::LODFaceList * >(argp2);
  if (arg1) (arg1)->mLodFaceList = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_mLodFaceList_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SubMesh::LODFaceList *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","mLodFaceList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::SubMesh::LODFaceList *)& ((arg1)->mLodFaceList);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_extremityPoints_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::vector< Ogre::Vector3,Ogre::STLAllocator< Ogre::Vector3,Ogre::GeneralAllocPolicy > >::type *arg2 = (Ogre::vector< Ogre::Vector3,Ogre::STLAllocator< Ogre::Vector3,Ogre::GeneralAllocPolicy > >::type *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","extremityPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::vector< Ogre::Vector3,Ogre::STLAllocator< Ogre::Vector3,Ogre::GeneralAllocPolicy > >::type *","extremityPoints", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::vector< Ogre::Vector3,Ogre::STLAllocator< Ogre::Vector3,Ogre::GeneralAllocPolicy > >::type * >(argp2);
  if (arg1) (arg1)->extremityPoints = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_extremityPoints_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::vector< Ogre::Vector3,Ogre::STLAllocator< Ogre::Vector3,Ogre::GeneralAllocPolicy > >::type *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","extremityPoints", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::vector< Ogre::Vector3,Ogre::STLAllocator< Ogre::Vector3,Ogre::GeneralAllocPolicy > >::type *)& ((arg1)->extremityPoints);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_parent_set(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::Mesh *arg2 = (Ogre::Mesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Mesh, SWIG_POINTER_DISOWN |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Mesh *","parent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Mesh * >(argp2);
  if (arg1) (arg1)->parent = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_parent_get(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Mesh *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","parent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::Mesh *) ((arg1)->parent);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Mesh, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_setMaterialName__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 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 &","setMaterialName", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_setMaterialName__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","setMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(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( "", "Ogre::String const &","setMaterialName", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setMaterialName", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setMaterialName((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_SubMesh_setMaterialName(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_Ogre__SubMesh, 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_SubMesh_setMaterialName__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SubMesh, 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_SubMesh_setMaterialName__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SubMesh.setMaterialName", 
    "    void SubMesh.setMaterialName(Ogre::String const &matName, Ogre::String const &groupName)\n"
    "    void SubMesh.setMaterialName(Ogre::String const &matName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_getMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","getMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::String *) &((Ogre::SubMesh const *)arg1)->getMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_isMatInitialised(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","isMatInitialised", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (bool)((Ogre::SubMesh const *)arg1)->isMatInitialised();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh__getRenderOperation__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::RenderOperation *arg2 = 0 ;
  Ogre::ushort arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","_getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","_getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","_getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ushort","_getRenderOperation", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::ushort >(val3);
  (arg1)->_getRenderOperation(*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh__getRenderOperation__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::RenderOperation *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","_getRenderOperation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__RenderOperation,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderOperation &","_getRenderOperation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::RenderOperation &","_getRenderOperation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::RenderOperation * >(argp2);
  (arg1)->_getRenderOperation(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_SubMesh__getRenderOperation(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_Ogre__SubMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderOperation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_SubMesh__getRenderOperation__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SubMesh, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__RenderOperation, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_SubMesh__getRenderOperation__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "SubMesh._getRenderOperation", 
    "    void SubMesh._getRenderOperation(Ogre::RenderOperation &rend, Ogre::ushort lodIndex)\n"
    "    void SubMesh._getRenderOperation(Ogre::RenderOperation &rend)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_addBoneAssignment(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::VertexBoneAssignment *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","addBoneAssignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__VertexBoneAssignment_s,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexBoneAssignment const &","addBoneAssignment", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::VertexBoneAssignment const &","addBoneAssignment", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::VertexBoneAssignment * >(argp2);
  (arg1)->addBoneAssignment((Ogre::VertexBoneAssignment const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_clearBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","clearBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  (arg1)->clearBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_getBoneAssignmentIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::multimap< size_t,Ogre::VertexBoneAssignment,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::VertexBoneAssignment >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","getBoneAssignmentIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (arg1)->getBoneAssignmentIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SubMesh::BoneAssignmentIterator(static_cast< const Ogre::SubMesh::BoneAssignmentIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_getBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SubMesh::VertexBoneAssignmentList *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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","getBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::SubMesh::VertexBoneAssignmentList *) &(arg1)->getBoneAssignments();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh__compileBoneAssignments(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","_compileBoneAssignments", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  (arg1)->_compileBoneAssignments();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_getAliasTextureIterator(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::String,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::String >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","getAliasTextureIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = ((Ogre::SubMesh const *)arg1)->getAliasTextureIterator();
  vresult = SWIG_NewPointerObj((new Ogre::SubMesh::AliasTextureIterator(static_cast< const Ogre::SubMesh::AliasTextureIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_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_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_addTextureAlias(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","addTextureAlias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(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( "", "Ogre::String const &","addTextureAlias", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addTextureAlias", 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 &","addTextureAlias", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addTextureAlias", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->addTextureAlias((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_removeTextureAlias(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  Ogre::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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","removeTextureAlias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(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( "", "Ogre::String const &","removeTextureAlias", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","removeTextureAlias", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->removeTextureAlias((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_removeAllTextureAliases(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","removeAllTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  (arg1)->removeAllTextureAliases();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_hasTextureAliases(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","hasTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (bool)((Ogre::SubMesh const *)arg1)->hasTextureAliases();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_getTextureAliasCount(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","getTextureAliasCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = ((Ogre::SubMesh const *)arg1)->getTextureAliasCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_updateMaterialUsingTextureAliases(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","updateMaterialUsingTextureAliases", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (bool)(arg1)->updateMaterialUsingTextureAliases();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_getVertexAnimationType(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::VertexAnimationType 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","getVertexAnimationType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (Ogre::VertexAnimationType)((Ogre::SubMesh const *)arg1)->getVertexAnimationType();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_getVertexAnimationIncludesNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","getVertexAnimationIncludesNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (bool)((Ogre::SubMesh const *)arg1)->getVertexAnimationIncludesNormals();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_generateExtremes(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","generateExtremes", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","generateExtremes", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  (arg1)->generateExtremes(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_isBuildEdgesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh const *","isBuildEdgesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  result = (bool)((Ogre::SubMesh const *)arg1)->isBuildEdgesEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SubMesh_setBuildEdgesEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::SubMesh *arg1 = (Ogre::SubMesh *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__SubMesh, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SubMesh *","setBuildEdgesEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SubMesh * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBuildEdgesEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBuildEdgesEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassTagPoint;

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

SWIGINTERN VALUE
_wrap_new_TagPoint(int argc, VALUE *argv, VALUE self) {
  unsigned short arg1 ;
  Ogre::Skeleton *arg2 = (Ogre::Skeleton *) 0 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TagPoint";
  Ogre::TagPoint *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "unsigned short","Ogre::TagPoint", 1, argv[0] ));
  } 
  arg1 = static_cast< unsigned short >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__Skeleton, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Skeleton *","Ogre::TagPoint", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::Skeleton * >(argp2);
  result = (Ogre::TagPoint *)new Ogre::TagPoint(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TagPoint(Ogre::TagPoint *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TagPoint_getParentEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Entity *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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","getParentEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  result = (Ogre::Entity *)((Ogre::TagPoint const *)arg1)->getParentEntity();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_getChildObject(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MovableObject *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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","getChildObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  result = (Ogre::MovableObject *)((Ogre::TagPoint const *)arg1)->getChildObject();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_setParentEntity(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  Ogre::Entity *arg2 = (Ogre::Entity *) 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint *","setParentEntity", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Entity, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Entity *","setParentEntity", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Entity * >(argp2);
  (arg1)->setParentEntity(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_setChildObject(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  Ogre::MovableObject *arg2 = (Ogre::MovableObject *) 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint *","setChildObject", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__MovableObject, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MovableObject *","setChildObject", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::MovableObject * >(argp2);
  (arg1)->setChildObject(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_setInheritParentEntityOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint *","setInheritParentEntityOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInheritParentEntityOrientation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setInheritParentEntityOrientation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_getInheritParentEntityOrientation(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","getInheritParentEntityOrientation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  result = (bool)((Ogre::TagPoint const *)arg1)->getInheritParentEntityOrientation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_setInheritParentEntityScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint *","setInheritParentEntityScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setInheritParentEntityScale", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setInheritParentEntityScale(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_getInheritParentEntityScale(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","getInheritParentEntityScale", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  result = (bool)((Ogre::TagPoint const *)arg1)->getInheritParentEntityScale();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_getParentEntityTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","getParentEntityTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::TagPoint const *)arg1)->getParentEntityTransform();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint__getFullLocalTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Matrix4 *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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","_getFullLocalTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  result = (Ogre::Matrix4 *) &((Ogre::TagPoint const *)arg1)->_getFullLocalTransform();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_needUpdate__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint *","needUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","needUpdate", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->needUpdate(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_needUpdate__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint *","needUpdate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  (arg1)->needUpdate();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TagPoint_needUpdate(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_Ogre__TagPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TagPoint_needUpdate__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TagPoint, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TagPoint_needUpdate__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TagPoint.needUpdate", 
    "    void TagPoint.needUpdate(bool forceParentUpdate)\n"
    "    void TagPoint.needUpdate()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_updateFromParentImpl(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","updateFromParentImpl", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  ((Ogre::TagPoint const *)arg1)->updateFromParentImpl();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TagPoint_getLights(int argc, VALUE *argv, VALUE self) {
  Ogre::TagPoint *arg1 = (Ogre::TagPoint *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::LightList *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_Ogre__TagPoint, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TagPoint const *","getLights", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TagPoint * >(argp1);
  result = (Ogre::LightList *) &((Ogre::TagPoint const *)arg1)->getLights();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HashedVectorT_Ogre__Light_p_t, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassTangentSpaceCalc;

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

SWIGINTERN VALUE
_wrap_new_TangentSpaceCalc(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TangentSpaceCalc";
  Ogre::TangentSpaceCalc *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TangentSpaceCalc *)new Ogre::TangentSpaceCalc();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TangentSpaceCalc(Ogre::TangentSpaceCalc *arg1) {
    delete arg1;
}


/*
  Document-method: Ogre::TangentSpaceCalc.clear

  call-seq:
    clear

Clear TangentSpaceCalc contents.
*/
SWIGINTERN VALUE
_wrap_TangentSpaceCalc_clear(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","clear", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  (arg1)->clear();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_setVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  Ogre::VertexData *arg2 = (Ogre::VertexData *) 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","setVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__VertexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::VertexData *","setVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::VertexData * >(argp2);
  (arg1)->setVertexData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_addIndexData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  Ogre::IndexData *arg2 = (Ogre::IndexData *) 0 ;
  Ogre::RenderOperation::OperationType arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","addIndexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IndexData *","addIndexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IndexData * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::RenderOperation::OperationType","addIndexData", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::RenderOperation::OperationType >(val3);
  (arg1)->addIndexData(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_addIndexData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  Ogre::IndexData *arg2 = (Ogre::IndexData *) 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","addIndexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__IndexData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::IndexData *","addIndexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::IndexData * >(argp2);
  (arg1)->addIndexData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TangentSpaceCalc_addIndexData(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_Ogre__TangentSpaceCalc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__IndexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TangentSpaceCalc_addIndexData__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TangentSpaceCalc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__IndexData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_int(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TangentSpaceCalc_addIndexData__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TangentSpaceCalc.addIndexData", 
    "    void TangentSpaceCalc.addIndexData(Ogre::IndexData *i_in, Ogre::RenderOperation::OperationType opType)\n"
    "    void TangentSpaceCalc.addIndexData(Ogre::IndexData *i_in)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_setStoreParityInW(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","setStoreParityInW", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setStoreParityInW", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setStoreParityInW(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_getStoreParityInW(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc const *","getStoreParityInW", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  result = (bool)((Ogre::TangentSpaceCalc const *)arg1)->getStoreParityInW();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_setSplitMirrored(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","setSplitMirrored", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitMirrored", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitMirrored(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_getSplitMirrored(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc const *","getSplitMirrored", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  result = (bool)((Ogre::TangentSpaceCalc const *)arg1)->getSplitMirrored();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_setSplitRotated(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","setSplitRotated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setSplitRotated", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setSplitRotated(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_getSplitRotated(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc const *","getSplitRotated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  result = (bool)((Ogre::TangentSpaceCalc const *)arg1)->getSplitRotated();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_build__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  unsigned short arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  Ogre::TangentSpaceCalc::Result 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","build", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","build", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "unsigned short","build", 4, argv[2] ));
  } 
  arg4 = static_cast< unsigned short >(val4);
  result = (arg1)->build(arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::TangentSpaceCalc::Result(static_cast< const Ogre::TangentSpaceCalc::Result& >(result))), SWIGTYPE_p_Ogre__TangentSpaceCalc__Result, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_build__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  unsigned short arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  Ogre::TangentSpaceCalc::Result 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","build", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "unsigned short","build", 3, argv[1] ));
  } 
  arg3 = static_cast< unsigned short >(val3);
  result = (arg1)->build(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::TangentSpaceCalc::Result(static_cast< const Ogre::TangentSpaceCalc::Result& >(result))), SWIGTYPE_p_Ogre__TangentSpaceCalc__Result, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_build__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  Ogre::VertexElementSemantic arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::TangentSpaceCalc::Result 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::VertexElementSemantic","build", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::VertexElementSemantic >(val2);
  result = (arg1)->build(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::TangentSpaceCalc::Result(static_cast< const Ogre::TangentSpaceCalc::Result& >(result))), SWIGTYPE_p_Ogre__TangentSpaceCalc__Result, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TangentSpaceCalc_build__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TangentSpaceCalc *arg1 = (Ogre::TangentSpaceCalc *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TangentSpaceCalc::Result 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_Ogre__TangentSpaceCalc, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TangentSpaceCalc *","build", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TangentSpaceCalc * >(argp1);
  result = (arg1)->build();
  vresult = SWIG_NewPointerObj((new Ogre::TangentSpaceCalc::Result(static_cast< const Ogre::TangentSpaceCalc::Result& >(result))), SWIGTYPE_p_Ogre__TangentSpaceCalc__Result, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TangentSpaceCalc_build(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TangentSpaceCalc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TangentSpaceCalc_build__SWIG_3(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TangentSpaceCalc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TangentSpaceCalc_build__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TangentSpaceCalc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TangentSpaceCalc_build__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TangentSpaceCalc, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_short(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TangentSpaceCalc_build__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TangentSpaceCalc.build", 
    "    Ogre::TangentSpaceCalc::Result TangentSpaceCalc.build(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet, unsigned short index)\n"
    "    Ogre::TangentSpaceCalc::Result TangentSpaceCalc.build(Ogre::VertexElementSemantic targetSemantic, unsigned short sourceTexCoordSet)\n"
    "    Ogre::TangentSpaceCalc::Result TangentSpaceCalc.build(Ogre::VertexElementSemantic targetSemantic)\n"
    "    Ogre::TangentSpaceCalc::Result TangentSpaceCalc.build()\n");
  
  return Qnil;
}


swig_class SwigClassUnifiedHighLevelGpuProgram;

SWIGINTERN VALUE
_wrap_new_UnifiedHighLevelGpuProgram__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  Ogre::ManualResourceLoader *arg6 = (Ogre::ManualResourceLoader *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UnifiedHighLevelGpuProgram";
  Ogre::UnifiedHighLevelGpuProgram *result = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::UnifiedHighLevelGpuProgram", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::UnifiedHighLevelGpuProgram", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::UnifiedHighLevelGpuProgram", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  res6 = SWIG_ConvertPtr(argv[5], &argp6,SWIGTYPE_p_Ogre__ManualResourceLoader, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::ManualResourceLoader *","Ogre::UnifiedHighLevelGpuProgram", 6, argv[5] )); 
  }
  arg6 = reinterpret_cast< Ogre::ManualResourceLoader * >(argp6);
  result = (Ogre::UnifiedHighLevelGpuProgram *)new Ogre::UnifiedHighLevelGpuProgram(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5,arg6);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_UnifiedHighLevelGpuProgram__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  bool val5 ;
  int ecode5 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::UnifiedHighLevelGpuProgram";
  Ogre::UnifiedHighLevelGpuProgram *result = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::UnifiedHighLevelGpuProgram", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::UnifiedHighLevelGpuProgram", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  ecode5 = SWIG_AsVal_bool(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","Ogre::UnifiedHighLevelGpuProgram", 5, argv[4] ));
  } 
  arg5 = static_cast< bool >(val5);
  result = (Ogre::UnifiedHighLevelGpuProgram *)new Ogre::UnifiedHighLevelGpuProgram(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4,arg5);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_UnifiedHighLevelGpuProgram__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ResourceManager *arg1 = (Ogre::ResourceManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::ResourceHandle arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  unsigned long long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::UnifiedHighLevelGpuProgram";
  Ogre::UnifiedHighLevelGpuProgram *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__ResourceManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ResourceManager *","Ogre::UnifiedHighLevelGpuProgram", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::ResourceManager * >(argp1);
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_unsigned_SS_long_SS_long(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::ResourceHandle","Ogre::UnifiedHighLevelGpuProgram", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::ResourceHandle >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[3], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 4, argv[3] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::UnifiedHighLevelGpuProgram", 4, argv[3])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::UnifiedHighLevelGpuProgram *)new Ogre::UnifiedHighLevelGpuProgram(arg1,(Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return self;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_UnifiedHighLevelGpuProgram(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_new_UnifiedHighLevelGpuProgram__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              return _wrap_new_UnifiedHighLevelGpuProgram__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ResourceManager, 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_AsVal_unsigned_SS_long_SS_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            {
              int res = SWIG_AsVal_bool(argv[4], NULL);
              _v = SWIG_CheckState(res);
            }
            if (_v) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__ManualResourceLoader, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_new_UnifiedHighLevelGpuProgram__SWIG_0(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "UnifiedHighLevelGpuProgram.new", 
    "    UnifiedHighLevelGpuProgram.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual, Ogre::ManualResourceLoader *loader)\n"
    "    UnifiedHighLevelGpuProgram.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group, bool isManual)\n"
    "    UnifiedHighLevelGpuProgram.new(Ogre::ResourceManager *creator, Ogre::String const &name, Ogre::ResourceHandle handle, Ogre::String const &group)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_UnifiedHighLevelGpuProgram(Ogre::UnifiedHighLevelGpuProgram *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_addDelegateProgram(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  Ogre::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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","addDelegateProgram", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(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( "", "Ogre::String const &","addDelegateProgram", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","addDelegateProgram", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->addDelegateProgram((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_clearDelegatePrograms(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","clearDelegatePrograms", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  (arg1)->clearDelegatePrograms();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram__getDelegate(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::HighLevelGpuProgramPtr *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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","_getDelegate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (Ogre::HighLevelGpuProgramPtr *) &((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->_getDelegate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__HighLevelGpuProgramPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_getLanguage(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","getLanguage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (Ogre::String *) &((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getLanguage();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_createParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","createParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (arg1)->createParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram__getBindingDelegate(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::GpuProgram *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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","_getBindingDelegate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (Ogre::GpuProgram *)(arg1)->_getBindingDelegate();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__GpuProgram, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isSupported();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isSkeletalAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isSkeletalAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isSkeletalAnimationIncluded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isMorphAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isMorphAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isMorphAnimationIncluded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isPoseAnimationIncluded(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isPoseAnimationIncluded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isPoseAnimationIncluded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isVertexTextureFetchRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isVertexTextureFetchRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isVertexTextureFetchRequired();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_getDefaultParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::GpuProgramParameters > > 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","getDefaultParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (arg1)->getDefaultParameters();
  vresult = SWIG_NewPointerObj((new Ogre::GpuProgramParametersSharedPtr(static_cast< const Ogre::GpuProgramParametersSharedPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__GpuProgramParameters_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_hasDefaultParameters(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","hasDefaultParameters", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->hasDefaultParameters();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_getPassSurfaceAndLightStates(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","getPassSurfaceAndLightStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getPassSurfaceAndLightStates();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_getPassFogStates(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","getPassFogStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getPassFogStates();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_getPassTransformStates(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","getPassTransformStates", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getPassTransformStates();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_hasCompileError(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","hasCompileError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->hasCompileError();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_resetCompileError(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","resetCompileError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  (arg1)->resetCompileError();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","load", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->load(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_UnifiedHighLevelGpuProgram_load(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_Ogre__UnifiedHighLevelGpuProgram, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_UnifiedHighLevelGpuProgram_load__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__UnifiedHighLevelGpuProgram, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_UnifiedHighLevelGpuProgram_load__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "UnifiedHighLevelGpuProgram.load", 
    "    void UnifiedHighLevelGpuProgram.load(bool backgroundThread)\n"
    "    void UnifiedHighLevelGpuProgram.load()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_reload(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","reload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  (arg1)->reload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isReloadable(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isReloadable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isReloadable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isLoading();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_getLoadingState(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Resource::LoadingState 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","getLoadingState", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (Ogre::Resource::LoadingState)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getLoadingState();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = ((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->getSize();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_touch(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","touch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  (arg1)->touch();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_isBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram const *","isBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  result = (bool)((Ogre::UnifiedHighLevelGpuProgram const *)arg1)->isBackgroundLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_setBackgroundLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","setBackgroundLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setBackgroundLoaded", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setBackgroundLoaded(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_escalateLoading(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","escalateLoading", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  (arg1)->escalateLoading();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_addListener(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","addListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","addListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (arg1)->addListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_UnifiedHighLevelGpuProgram_removeListener(int argc, VALUE *argv, VALUE self) {
  Ogre::UnifiedHighLevelGpuProgram *arg1 = (Ogre::UnifiedHighLevelGpuProgram *) 0 ;
  Ogre::Resource::Listener *arg2 = (Ogre::Resource::Listener *) 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_Ogre__UnifiedHighLevelGpuProgram, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::UnifiedHighLevelGpuProgram *","removeListener", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::UnifiedHighLevelGpuProgram * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Resource__Listener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Resource::Listener *","removeListener", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Resource::Listener * >(argp2);
  (arg1)->removeListener(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassWindowEventListener;

SWIGINTERN void
free_Ogre_WindowEventListener(Ogre::WindowEventListener *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_WindowEventListener_windowMoved(int argc, VALUE *argv, VALUE self) {
  Ogre::WindowEventListener *arg1 = (Ogre::WindowEventListener *) 0 ;
  Ogre::RenderWindow *arg2 = (Ogre::RenderWindow *) 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_Ogre__WindowEventListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WindowEventListener *","windowMoved", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WindowEventListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","windowMoved", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderWindow * >(argp2);
  (arg1)->windowMoved(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventListener_windowResized(int argc, VALUE *argv, VALUE self) {
  Ogre::WindowEventListener *arg1 = (Ogre::WindowEventListener *) 0 ;
  Ogre::RenderWindow *arg2 = (Ogre::RenderWindow *) 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_Ogre__WindowEventListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WindowEventListener *","windowResized", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WindowEventListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","windowResized", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderWindow * >(argp2);
  (arg1)->windowResized(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventListener_windowClosing(int argc, VALUE *argv, VALUE self) {
  Ogre::WindowEventListener *arg1 = (Ogre::WindowEventListener *) 0 ;
  Ogre::RenderWindow *arg2 = (Ogre::RenderWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__WindowEventListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WindowEventListener *","windowClosing", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WindowEventListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","windowClosing", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderWindow * >(argp2);
  result = (bool)(arg1)->windowClosing(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventListener_windowClosed(int argc, VALUE *argv, VALUE self) {
  Ogre::WindowEventListener *arg1 = (Ogre::WindowEventListener *) 0 ;
  Ogre::RenderWindow *arg2 = (Ogre::RenderWindow *) 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_Ogre__WindowEventListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WindowEventListener *","windowClosed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WindowEventListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","windowClosed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderWindow * >(argp2);
  (arg1)->windowClosed(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventListener_windowFocusChange(int argc, VALUE *argv, VALUE self) {
  Ogre::WindowEventListener *arg1 = (Ogre::WindowEventListener *) 0 ;
  Ogre::RenderWindow *arg2 = (Ogre::RenderWindow *) 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_Ogre__WindowEventListener, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WindowEventListener *","windowFocusChange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WindowEventListener * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","windowFocusChange", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::RenderWindow * >(argp2);
  (arg1)->windowFocusChange(arg2);
  return Qnil;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_WindowEventListener(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::WindowEventListener";
  Ogre::WindowEventListener *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::WindowEventListener *)new Ogre::WindowEventListener();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


swig_class SwigClassWindowEventUtilities;

SWIGINTERN VALUE
_wrap_WindowEventUtilities_messagePump(int argc, VALUE *argv, VALUE self) {
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  Ogre::WindowEventUtilities::messagePump();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities_addWindowEventListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  Ogre::WindowEventListener *arg2 = (Ogre::WindowEventListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","Ogre::WindowEventUtilities::addWindowEventListener", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__WindowEventListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WindowEventListener *","Ogre::WindowEventUtilities::addWindowEventListener", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::WindowEventListener * >(argp2);
  Ogre::WindowEventUtilities::addWindowEventListener(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities_removeWindowEventListener(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  Ogre::WindowEventListener *arg2 = (Ogre::WindowEventListener *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","Ogre::WindowEventUtilities::removeWindowEventListener", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__WindowEventListener, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WindowEventListener *","Ogre::WindowEventUtilities::removeWindowEventListener", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::WindowEventListener * >(argp2);
  Ogre::WindowEventUtilities::removeWindowEventListener(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities__addRenderWindow(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","Ogre::WindowEventUtilities::_addRenderWindow", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  Ogre::WindowEventUtilities::_addRenderWindow(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities__removeRenderWindow(int argc, VALUE *argv, VALUE self) {
  Ogre::RenderWindow *arg1 = (Ogre::RenderWindow *) 0 ;
  void *argp1 = 0 ;
  int res1 = 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__RenderWindow, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::RenderWindow *","Ogre::WindowEventUtilities::_removeRenderWindow", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::RenderWindow * >(argp1);
  Ogre::WindowEventUtilities::_removeRenderWindow(arg1);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities__msListeners_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::WindowEventUtilities::_msListeners), SWIGTYPE_p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities__msListeners_set(VALUE self, VALUE _val) {
  {
    void *argp = 0;
    int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::WindowEventUtilities::_msListeners""' of type '""Ogre::WindowEventUtilities::WindowEventListeners""'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Ogre::WindowEventUtilities::_msListeners""' of type '""Ogre::WindowEventUtilities::WindowEventListeners""'");
    } else {
      Ogre::WindowEventUtilities::_msListeners = *(reinterpret_cast< Ogre::WindowEventUtilities::WindowEventListeners * >(argp));
    }
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities__msWindows_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_NewPointerObj(SWIG_as_voidptr(&Ogre::WindowEventUtilities::_msWindows), SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  return _val;
}


SWIGINTERN VALUE
_wrap_WindowEventUtilities__msWindows_set(VALUE self, VALUE _val) {
  {
    void *argp = 0;
    int res = SWIG_ConvertPtr(_val, &argp, SWIGTYPE_p_Ogre__vectorT_Ogre__RenderWindow_p_Ogre__STLAllocatorT_Ogre__RenderWindow_p_Ogre__GeneralAllocPolicy_t_t__type,  0 );
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::WindowEventUtilities::_msWindows""' of type '""Ogre::WindowEventUtilities::Windows""'");
    }
    if (!argp) {
      SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in variable '""Ogre::WindowEventUtilities::_msWindows""' of type '""Ogre::WindowEventUtilities::Windows""'");
    } else {
      Ogre::WindowEventUtilities::_msWindows = *(reinterpret_cast< Ogre::WindowEventUtilities::Windows * >(argp));
    }
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_WindowEventUtilities(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::WindowEventUtilities";
  Ogre::WindowEventUtilities *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::WindowEventUtilities *)new Ogre::WindowEventUtilities();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_WindowEventUtilities(Ogre::WindowEventUtilities *arg1) {
    delete arg1;
}

swig_class SwigClassWireBoundingBox;

SWIGINTERN VALUE
_wrap_new_WireBoundingBox__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::WireBoundingBox";
  Ogre::WireBoundingBox *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::WireBoundingBox *)new Ogre::WireBoundingBox();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_WireBoundingBox__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::WireBoundingBox";
  Ogre::WireBoundingBox *result = 0 ;
  
  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 &","Ogre::WireBoundingBox", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::WireBoundingBox", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  result = (Ogre::WireBoundingBox *)new Ogre::WireBoundingBox((Ogre::String const &)*arg1);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_WireBoundingBox(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_WireBoundingBox__SWIG_0(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_new_WireBoundingBox__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 1, "WireBoundingBox.new", 
    "    WireBoundingBox.new()\n"
    "    WireBoundingBox.new(Ogre::String const &name)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_WireBoundingBox(Ogre::WireBoundingBox *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_WireBoundingBox_setupBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::WireBoundingBox *arg1 = (Ogre::WireBoundingBox *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__WireBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WireBoundingBox *","setupBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WireBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","setupBoundingBox", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","setupBoundingBox", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->setupBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WireBoundingBox_getSquaredViewDepth(int argc, VALUE *argv, VALUE self) {
  Ogre::WireBoundingBox *arg1 = (Ogre::WireBoundingBox *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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_Ogre__WireBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WireBoundingBox const *","getSquaredViewDepth", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WireBoundingBox * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","getSquaredViewDepth", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (Ogre::Real)((Ogre::WireBoundingBox const *)arg1)->getSquaredViewDepth((Ogre::Camera const *)arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_WireBoundingBox_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::WireBoundingBox *arg1 = (Ogre::WireBoundingBox *) 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_Ogre__WireBoundingBox, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::WireBoundingBox const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::WireBoundingBox * >(argp1);
  result = (Ogre::Real)((Ogre::WireBoundingBox const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassZipArchive;

SWIGINTERN VALUE
_wrap_new_ZipArchive__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  zzip_plugin_io_handlers *arg3 = (zzip_plugin_io_handlers *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::ZipArchive";
  Ogre::ZipArchive *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::ZipArchive", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ZipArchive", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ZipArchive", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ZipArchive", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p__zzip_plugin_io, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "zzip_plugin_io_handlers *","Ogre::ZipArchive", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< zzip_plugin_io_handlers * >(argp3);
  result = (Ogre::ZipArchive *)new Ogre::ZipArchive((Ogre::String const &)*arg1,(Ogre::String const &)*arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_ZipArchive__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::String *arg2 = 0 ;
  int res1 = SWIG_OLDOBJ ;
  int res2 = SWIG_OLDOBJ ;
  const char *classname SWIGUNUSED = "Ogre::ZipArchive";
  Ogre::ZipArchive *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::ZipArchive", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ZipArchive", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res2 = SWIG_AsPtr_std_string(argv[1], &ptr);
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::String const &","Ogre::ZipArchive", 2, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::ZipArchive", 2, argv[1])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::ZipArchive *)new Ogre::ZipArchive((Ogre::String const &)*arg1,(Ogre::String const &)*arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_ZipArchive(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 == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(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_new_ZipArchive__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p__zzip_plugin_io, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_new_ZipArchive__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "ZipArchive.new", 
    "    ZipArchive.new(Ogre::String const &name, Ogre::String const &archType, zzip_plugin_io_handlers *pluginIo)\n"
    "    ZipArchive.new(Ogre::String const &name, Ogre::String const &archType)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_ZipArchive(Ogre::ZipArchive *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_ZipArchive_isCaseSensitive(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","isCaseSensitive", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  result = (bool)((Ogre::ZipArchive const *)arg1)->isCaseSensitive();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_load(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_open__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","open", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","open", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","open", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = ((Ogre::ZipArchive const *)arg1)->open((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_open__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","open", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","open", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","open", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::ZipArchive const *)arg1)->open((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ZipArchive_open(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_Ogre__ZipArchive, 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_ZipArchive_open__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZipArchive_open__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ZipArchive.open", 
    "    Ogre::DataStreamPtr ZipArchive.open(Ogre::String const &filename, bool readOnly)\n"
    "    Ogre::DataStreamPtr ZipArchive.open(Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_create(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::DataStream > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","create", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","create", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","create", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::ZipArchive const *)arg1)->create((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::DataStreamPtr(static_cast< const Ogre::DataStreamPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_remove(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","remove", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","remove", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","remove", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ((Ogre::ZipArchive const *)arg1)->remove((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_list__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","list", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","list", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->list(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_list__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","list", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->list(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_list__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","list", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  result = (arg1)->list();
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ZipArchive_list(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_Ogre__ZipArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ZipArchive_list__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ZipArchive_list__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZipArchive_list__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ZipArchive.list", 
    "    Ogre::StringVectorPtr ZipArchive.list(bool recursive, bool dirs)\n"
    "    Ogre::StringVectorPtr ZipArchive.list(bool recursive)\n"
    "    Ogre::StringVectorPtr ZipArchive.list()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_listFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","listFileInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","listFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->listFileInfo(arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_listFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","listFileInfo", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  result = (arg1)->listFileInfo(arg2);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_listFileInfo__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","listFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(argp1);
  result = (arg1)->listFileInfo();
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_ZipArchive_listFileInfo(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_Ogre__ZipArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_ZipArchive_listFileInfo__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_ZipArchive_listFileInfo__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZipArchive_listFileInfo__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "ZipArchive.listFileInfo", 
    "    Ogre::FileInfoListPtr ZipArchive.listFileInfo(bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr ZipArchive.listFileInfo(bool recursive)\n"
    "    Ogre::FileInfoListPtr ZipArchive.listFileInfo()\n");
  
  return Qnil;
}



/*
  Document-method: Ogre::ZipArchive.find

  call-seq:
    find(pattern, recursive=true, dirs=false) -> StringVectorPtr
    find(pattern, recursive=true) -> StringVectorPtr
    find(pattern) -> StringVectorPtr

Find an element in the class.
*/
SWIGINTERN VALUE
_wrap_ZipArchive_find__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","find", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","find", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = (arg1)->find((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_find__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","find", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->find((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_find__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::String,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","find", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","find", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","find", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->find((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::StringVectorPtr(static_cast< const Ogre::StringVectorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ZipArchive_find(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_Ogre__ZipArchive, 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_ZipArchive_find__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZipArchive_find__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ZipArchive_find__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ZipArchive.find", 
    "    Ogre::StringVectorPtr ZipArchive.find(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::StringVectorPtr ZipArchive.find(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::StringVectorPtr ZipArchive.find(Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_findFileInfo__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","findFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","findFileInfo", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  result = ((Ogre::ZipArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_findFileInfo__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","findFileInfo", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = ((Ogre::ZipArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_findFileInfo__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::vector< Ogre::FileInfo,Ogre::STLAllocator< Ogre::FileInfo,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive const *","findFileInfo", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","findFileInfo", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","findFileInfo", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = ((Ogre::ZipArchive const *)arg1)->findFileInfo((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::FileInfoListPtr(static_cast< const Ogre::FileInfoListPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__vectorT_Ogre__FileInfo_Ogre__STLAllocatorT_Ogre__FileInfo_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_ZipArchive_findFileInfo(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_Ogre__ZipArchive, 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_ZipArchive_findFileInfo__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_ZipArchive_findFileInfo__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__ZipArchive, 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_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_ZipArchive_findFileInfo__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "ZipArchive.findFileInfo", 
    "    Ogre::FileInfoListPtr ZipArchive.findFileInfo(Ogre::String const &pattern, bool recursive, bool dirs)\n"
    "    Ogre::FileInfoListPtr ZipArchive.findFileInfo(Ogre::String const &pattern, bool recursive)\n"
    "    Ogre::FileInfoListPtr ZipArchive.findFileInfo(Ogre::String const &pattern)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_exists(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","exists", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","exists", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","exists", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->exists((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_ZipArchive_getModifiedTime(int argc, VALUE *argv, VALUE self) {
  Ogre::ZipArchive *arg1 = (Ogre::ZipArchive *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  time_t 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_Ogre__ZipArchive, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::ZipArchive *","getModifiedTime", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::ZipArchive * >(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( "", "Ogre::String const &","getModifiedTime", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getModifiedTime", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (arg1)->getModifiedTime((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj((new time_t(static_cast< const time_t& >(result))), SWIGTYPE_p_time_t, SWIG_POINTER_OWN |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


swig_class SwigClassEmbeddedZipArchiveFactory;

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

SWIGINTERN VALUE
_wrap_new_EmbeddedZipArchiveFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::EmbeddedZipArchiveFactory";
  Ogre::EmbeddedZipArchiveFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::EmbeddedZipArchiveFactory *)new Ogre::EmbeddedZipArchiveFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_EmbeddedZipArchiveFactory(Ogre::EmbeddedZipArchiveFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::EmbeddedZipArchiveFactory *arg1 = (Ogre::EmbeddedZipArchiveFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__EmbeddedZipArchiveFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmbeddedZipArchiveFactory const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmbeddedZipArchiveFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::EmbeddedZipArchiveFactory const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::EmbeddedZipArchiveFactory *arg1 = (Ogre::EmbeddedZipArchiveFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::Archive *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_Ogre__EmbeddedZipArchiveFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::EmbeddedZipArchiveFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::EmbeddedZipArchiveFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::Archive *)(arg1)->createInstance((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Archive, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_addEmbbeddedFile(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::uint8 *arg2 = (Ogre::uint8 *) 0 ;
  size_t arg3 ;
  Ogre::EmbeddedZipArchiveFactory::DecryptEmbeddedZipFileFunc arg4 = (Ogre::EmbeddedZipArchiveFactory::DecryptEmbeddedZipFileFunc) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",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 &","Ogre::EmbeddedZipArchiveFactory::addEmbbeddedFile", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::EmbeddedZipArchiveFactory::addEmbbeddedFile", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_unsigned_char, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::uint8 const *","Ogre::EmbeddedZipArchiveFactory::addEmbbeddedFile", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::uint8 * >(argp2);
  ecode3 = SWIG_AsVal_size_t(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","Ogre::EmbeddedZipArchiveFactory::addEmbbeddedFile", 3, argv[2] ));
  } 
  arg3 = static_cast< size_t >(val3);
  {
    int res = SWIG_ConvertFunctionPtr(argv[3], (void**)(&arg4), SWIGTYPE_p_f_size_t_p_void_size_t__bool);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), Ruby_Format_TypeError( "", "Ogre::EmbeddedZipArchiveFactory::DecryptEmbeddedZipFileFunc","Ogre::EmbeddedZipArchiveFactory::addEmbbeddedFile", 4, argv[3] )); 
    }
  }
  Ogre::EmbeddedZipArchiveFactory::addEmbbeddedFile((std::string const &)*arg1,(unsigned char const *)arg2,arg3,arg4);
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_EmbeddedZipArchiveFactory_removeEmbbeddedFile(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 &","Ogre::EmbeddedZipArchiveFactory::removeEmbbeddedFile", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::EmbeddedZipArchiveFactory::removeEmbbeddedFile", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  Ogre::EmbeddedZipArchiveFactory::removeEmbbeddedFile((std::string const &)*arg1);
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


swig_class SwigClassPageStrategyData;

SWIGINTERN void
free_Ogre_PageStrategyData(Ogre::PageStrategyData *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageStrategyData_load(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategyData *arg1 = (Ogre::PageStrategyData *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategyData *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategyData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->load(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategyData_save(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategyData *arg1 = (Ogre::PageStrategyData *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__PageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategyData *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategyData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPageStrategy;

SWIGINTERN void
free_Ogre_PageStrategy(Ogre::PageStrategy *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageStrategy_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  result = (Ogre::String *) &((Ogre::PageStrategy const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager *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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  result = (Ogre::PageManager *)((Ogre::PageStrategy const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_frameStart(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","frameStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","frameStart", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  (arg1)->frameStart(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_frameEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  Ogre::Real arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","frameEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","frameEnd", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  (arg1)->frameEnd(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","notifyCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  (arg1)->notifyCamera(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_createData(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageStrategyData *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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","createData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  result = (Ogre::PageStrategyData *)(arg1)->createData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_destroyData(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  Ogre::PageStrategyData *arg2 = (Ogre::PageStrategyData *) 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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","destroyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategyData *","destroyData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategyData * >(argp2);
  (arg1)->destroyData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_updateDebugDisplay(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) 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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","updateDebugDisplay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","updateDebugDisplay", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *","updateDebugDisplay", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(argp3);
  (arg1)->updateDebugDisplay(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageStrategy_getPageID(int argc, VALUE *argv, VALUE self) {
  Ogre::PageStrategy *arg1 = (Ogre::PageStrategy *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::PageID 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_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","getPageID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageStrategy * >(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 &","getPageID", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getPageID", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","getPageID", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassGrid2DPageStrategyData;

SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Grid2DPageStrategyData::CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Grid2DPageStrategyData::CHUNK_VERSION));
  return _val;
}


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

SWIGINTERN VALUE
_wrap_new_Grid2DPageStrategyData(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Grid2DPageStrategyData";
  Ogre::Grid2DPageStrategyData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Grid2DPageStrategyData *)new Ogre::Grid2DPageStrategyData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid2DPageStrategyData(Ogre::Grid2DPageStrategyData *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Grid2DMode arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Grid2DMode","setMode", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Grid2DMode >(val2);
  (arg1)->setMode(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getMode(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Grid2DMode 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getMode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::Grid2DMode)((Ogre::Grid2DPageStrategyData const *)arg1)->getMode();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Vector3 *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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(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 &","setOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(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 &","getOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Vector3 *) &(arg1)->getOrigin((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setCellSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setCellSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setCellSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setCellSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getCellSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getCellSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::Real)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setLoadRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setLoadRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLoadRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setLoadRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getLoadRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getLoadRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::Real)((Ogre::Grid2DPageStrategyData const *)arg1)->getLoadRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setHoldRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setHoldRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHoldRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setHoldRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getHoldRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getHoldRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::Real)((Ogre::Grid2DPageStrategyData const *)arg1)->getHoldRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getLoadRadiusInCells(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","getLoadRadiusInCells", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::Real)(arg1)->getLoadRadiusInCells();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getHoldRadiusInCells(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","getHoldRadiusInCells", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::Real)(arg1)->getHoldRadiusInCells();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setCellRange(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::int32 arg4 ;
  Ogre::int32 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setCellRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::int32 >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::int32 >(val5);
  (arg1)->setCellRange(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setCellRangeMinX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setCellRangeMinX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMinX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMinX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setCellRangeMinY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setCellRangeMinY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMinY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMinY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setCellRangeMaxX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setCellRangeMaxX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMaxX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMaxX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_setCellRangeMaxY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","setCellRangeMaxY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMaxY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMaxY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getCellRangeMinX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getCellRangeMinX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMinX();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getCellRangeMinY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getCellRangeMinY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMinY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getCellRangeMaxX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getCellRangeMaxX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMaxX();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getCellRangeMaxY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData const *","getCellRangeMaxY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid2DPageStrategyData const *)arg1)->getCellRangeMaxY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_load(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->load(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_save(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_convertWorldToGridSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector2 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","convertWorldToGridSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(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 &","convertWorldToGridSpace", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertWorldToGridSpace", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(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 &","convertWorldToGridSpace", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 &","convertWorldToGridSpace", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector2 * >(argp3);
  (arg1)->convertWorldToGridSpace((Ogre::Vector3 const &)*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_convertGridToWorldSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","convertGridToWorldSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(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 &","convertGridToWorldSpace", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","convertGridToWorldSpace", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(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 &","convertGridToWorldSpace", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","convertGridToWorldSpace", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->convertGridToWorldSpace((Ogre::Vector2 const &)*arg2,*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getMidPointGridSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::Vector2 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","getMidPointGridSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","getMidPointGridSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","getMidPointGridSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  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 &","getMidPointGridSpace", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 &","getMidPointGridSpace", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector2 * >(argp4);
  (arg1)->getMidPointGridSpace(arg2,arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getBottomLeftGridSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::Vector2 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","getBottomLeftGridSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","getBottomLeftGridSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","getBottomLeftGridSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  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 &","getBottomLeftGridSpace", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 &","getBottomLeftGridSpace", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector2 * >(argp4);
  (arg1)->getBottomLeftGridSpace(arg2,arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_getCornersGridSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::Vector2 *arg4 = (Ogre::Vector2 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","getCornersGridSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","getCornersGridSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","getCornersGridSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector2, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector2 *","getCornersGridSpace", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector2 * >(argp4);
  (arg1)->getCornersGridSpace(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_determineGridLocation(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::Vector2 *arg2 = 0 ;
  Ogre::int32 *arg3 = (Ogre::int32 *) 0 ;
  Ogre::int32 *arg4 = (Ogre::int32 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","determineGridLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(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 &","determineGridLocation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector2 const &","determineGridLocation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector2 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::int32 *","determineGridLocation", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::int32 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::int32 *","determineGridLocation", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::int32 * >(argp4);
  (arg1)->determineGridLocation((Ogre::Vector2 const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_calculatePageID(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  Ogre::PageID 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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","calculatePageID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","calculatePageID", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","calculatePageID", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  result = (Ogre::PageID)(arg1)->calculatePageID(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategyData_calculateCell(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategyData *arg1 = (Ogre::Grid2DPageStrategyData *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::int32 *arg3 = (Ogre::int32 *) 0 ;
  Ogre::int32 *arg4 = (Ogre::int32 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Grid2DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategyData *","calculateCell", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","calculateCell", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::int32 *","calculateCell", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::int32 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::int32 *","calculateCell", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::int32 * >(argp4);
  (arg1)->calculateCell(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassGrid2DPageStrategy;

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

SWIGINTERN VALUE
_wrap_new_Grid2DPageStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Grid2DPageStrategy";
  Ogre::Grid2DPageStrategy *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__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","Ogre::Grid2DPageStrategy", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::Grid2DPageStrategy *)new Ogre::Grid2DPageStrategy(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid2DPageStrategy(Ogre::Grid2DPageStrategy *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategy *arg1 = (Ogre::Grid2DPageStrategy *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 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_Ogre__Grid2DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategy *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","notifyCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  (arg1)->notifyCamera(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_createData(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategy *arg1 = (Ogre::Grid2DPageStrategy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageStrategyData *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_Ogre__Grid2DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategy *","createData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategy * >(argp1);
  result = (Ogre::PageStrategyData *)(arg1)->createData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_destroyData(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategy *arg1 = (Ogre::Grid2DPageStrategy *) 0 ;
  Ogre::PageStrategyData *arg2 = (Ogre::PageStrategyData *) 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_Ogre__Grid2DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategy *","destroyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategyData *","destroyData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategyData * >(argp2);
  (arg1)->destroyData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_updateDebugDisplay(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategy *arg1 = (Ogre::Grid2DPageStrategy *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) 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_Ogre__Grid2DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategy *","updateDebugDisplay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","updateDebugDisplay", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *","updateDebugDisplay", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(argp3);
  (arg1)->updateDebugDisplay(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid2DPageStrategy_getPageID(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid2DPageStrategy *arg1 = (Ogre::Grid2DPageStrategy *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::PageID 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_Ogre__Grid2DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid2DPageStrategy *","getPageID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid2DPageStrategy * >(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 &","getPageID", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getPageID", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","getPageID", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassGrid3DPageStrategyData;

SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Grid3DPageStrategyData::CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Grid3DPageStrategyData::CHUNK_VERSION));
  return _val;
}


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

SWIGINTERN VALUE
_wrap_new_Grid3DPageStrategyData(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::Grid3DPageStrategyData";
  Ogre::Grid3DPageStrategyData *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::Grid3DPageStrategyData *)new Ogre::Grid3DPageStrategyData();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid3DPageStrategyData(Ogre::Grid3DPageStrategyData *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::Vector3 *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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(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 &","setOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(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 &","getOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Vector3 *) &(arg1)->getOrigin((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::Vector3 *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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(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 &","setCellSize", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setCellSize", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setCellSize((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCellSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getCellSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = ((Ogre::Grid3DPageStrategyData const *)arg1)->getCellSize();
  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_Grid3DPageStrategyData_setLoadRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setLoadRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLoadRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setLoadRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getLoadRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getLoadRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::Real)((Ogre::Grid3DPageStrategyData const *)arg1)->getLoadRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setHoldRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setHoldRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHoldRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setHoldRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getHoldRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getHoldRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::Real)((Ogre::Grid3DPageStrategyData const *)arg1)->getHoldRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellRange(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::int32 arg4 ;
  Ogre::int32 arg5 ;
  Ogre::int32 arg6 ;
  Ogre::int32 arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::int32 >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::int32 >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::int32 >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::int32","setCellRange", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::int32 >(val7);
  (arg1)->setCellRange(arg2,arg3,arg4,arg5,arg6,arg7);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellRangeMinX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellRangeMinX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMinX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMinX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellRangeMinY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellRangeMinY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMinY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMinY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellRangeMinZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellRangeMinZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMinZ", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMinZ(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellRangeMaxX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellRangeMaxX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMaxX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMaxX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellRangeMaxY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellRangeMaxY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMaxY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMaxY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_setCellRangeMaxZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","setCellRangeMaxZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setCellRangeMaxZ", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setCellRangeMaxZ(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCellRangeMinX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getCellRangeMinX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMinX();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCellRangeMinY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getCellRangeMinY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMinY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCellRangeMinZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getCellRangeMinZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMinZ();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCellRangeMaxX(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getCellRangeMaxX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMaxX();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCellRangeMaxY(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getCellRangeMaxY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMaxY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCellRangeMaxZ(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData const *","getCellRangeMaxZ", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  result = (Ogre::int32)((Ogre::Grid3DPageStrategyData const *)arg1)->getCellRangeMaxZ();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_load(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->load(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_save(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getMidPointGridSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::int32 arg4 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","getMidPointGridSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","getMidPointGridSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","getMidPointGridSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::int32","getMidPointGridSpace", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::int32 >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 &","getMidPointGridSpace", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","getMidPointGridSpace", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getMidPointGridSpace(arg2,arg3,arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getBottomLeftGridSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  int arg4 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","getBottomLeftGridSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","getBottomLeftGridSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","getBottomLeftGridSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "int","getBottomLeftGridSpace", 4, argv[2] ));
  } 
  arg4 = static_cast< int >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 &","getBottomLeftGridSpace", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","getBottomLeftGridSpace", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getBottomLeftGridSpace(arg2,arg3,arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_getCornersGridSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::int32 arg4 ;
  Ogre::Vector3 *arg5 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","getCornersGridSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","getCornersGridSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","getCornersGridSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::int32","getCornersGridSpace", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::int32 >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getCornersGridSpace", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getCornersGridSpace(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_determineGridLocation(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::int32 *arg3 = (Ogre::int32 *) 0 ;
  Ogre::int32 *arg4 = (Ogre::int32 *) 0 ;
  Ogre::int32 *arg5 = (Ogre::int32 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","determineGridLocation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(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 &","determineGridLocation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","determineGridLocation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::int32 *","determineGridLocation", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::int32 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::int32 *","determineGridLocation", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::int32 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::int32 *","determineGridLocation", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::int32 * >(argp5);
  (arg1)->determineGridLocation((Ogre::Vector3 const &)*arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_calculatePageID(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::int32 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::PageID 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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","calculatePageID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","calculatePageID", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","calculatePageID", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::int32","calculatePageID", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::int32 >(val4);
  result = (Ogre::PageID)(arg1)->calculatePageID(arg2,arg3,arg4);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategyData_calculateCell(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategyData *arg1 = (Ogre::Grid3DPageStrategyData *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::int32 *arg3 = (Ogre::int32 *) 0 ;
  Ogre::int32 *arg4 = (Ogre::int32 *) 0 ;
  Ogre::int32 *arg5 = (Ogre::int32 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Grid3DPageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategyData *","calculateCell", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategyData * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","calculateCell", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::int32 *","calculateCell", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::int32 * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::int32 *","calculateCell", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::int32 * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_int, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::int32 *","calculateCell", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::int32 * >(argp5);
  (arg1)->calculateCell(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassGrid3DPageStrategy;

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

SWIGINTERN VALUE
_wrap_new_Grid3DPageStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Grid3DPageStrategy";
  Ogre::Grid3DPageStrategy *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__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","Ogre::Grid3DPageStrategy", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::Grid3DPageStrategy *)new Ogre::Grid3DPageStrategy(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Grid3DPageStrategy(Ogre::Grid3DPageStrategy *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategy *arg1 = (Ogre::Grid3DPageStrategy *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 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_Ogre__Grid3DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategy *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","notifyCamera", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  (arg1)->notifyCamera(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_createData(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategy *arg1 = (Ogre::Grid3DPageStrategy *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageStrategyData *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_Ogre__Grid3DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategy *","createData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategy * >(argp1);
  result = (Ogre::PageStrategyData *)(arg1)->createData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_destroyData(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategy *arg1 = (Ogre::Grid3DPageStrategy *) 0 ;
  Ogre::PageStrategyData *arg2 = (Ogre::PageStrategyData *) 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_Ogre__Grid3DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategy *","destroyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategyData *","destroyData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategyData * >(argp2);
  (arg1)->destroyData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_updateDebugDisplay(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategy *arg1 = (Ogre::Grid3DPageStrategy *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::SceneNode *arg3 = (Ogre::SceneNode *) 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_Ogre__Grid3DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategy *","updateDebugDisplay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategy * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","updateDebugDisplay", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneNode *","updateDebugDisplay", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneNode * >(argp3);
  (arg1)->updateDebugDisplay(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Grid3DPageStrategy_getPageID(int argc, VALUE *argv, VALUE self) {
  Ogre::Grid3DPageStrategy *arg1 = (Ogre::Grid3DPageStrategy *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::PageID 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_Ogre__Grid3DPageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Grid3DPageStrategy *","getPageID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Grid3DPageStrategy * >(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 &","getPageID", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getPageID", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","getPageID", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPage;

SWIGINTERN VALUE
_wrap_Page_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Page::CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Page_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Page::CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Page_CHUNK_CONTENTCOLLECTION_DECLARATION_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Page::CHUNK_CONTENTCOLLECTION_DECLARATION_ID));
  return _val;
}


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

SWIGINTERN VALUE
_wrap_new_Page(int argc, VALUE *argv, VALUE self) {
  Ogre::PageID arg1 ;
  Ogre::PagedWorldSection *arg2 = (Ogre::PagedWorldSection *) 0 ;
  unsigned int val1 ;
  int ecode1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Page";
  Ogre::Page *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_int(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::PageID","Ogre::Page", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::PageID >(val1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","Ogre::Page", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorldSection * >(argp2);
  result = (Ogre::Page *)new Ogre::Page(arg1,arg2);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Page(Ogre::Page *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Page_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (Ogre::PageManager *)((Ogre::Page const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::Page const *)arg1)->getSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_isDeferredProcessInProgress(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","isDeferredProcessInProgress", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (bool)((Ogre::Page const *)arg1)->isDeferredProcessInProgress();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_getID(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageID 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","getID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (Ogre::PageID)((Ogre::Page const *)arg1)->getID();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_getParentSection(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PagedWorldSection *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","getParentSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (Ogre::PagedWorldSection *)((Ogre::Page const *)arg1)->getParentSection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_getFrameLastHeld(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","getFrameLastHeld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (unsigned long)(arg1)->getFrameLastHeld();
  vresult = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_touch(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","touch", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  (arg1)->touch();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_load(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","load", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->load(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_isHeld(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","isHeld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (bool)((Ogre::Page const *)arg1)->isHeld();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_save__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  (arg1)->save();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_save__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(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( "", "Ogre::String const &","save", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","save", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->save((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_save__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Page_save(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_Ogre__Page, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Page_save__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Page, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Page_save__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Page, 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_Page_save__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Page.save", 
    "    void Page.save()\n"
    "    void Page.save(Ogre::String const &filename)\n"
    "    void Page.save(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_frameStart(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","frameStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameStart(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_frameEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","frameEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->notifyCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_createContentCollection(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PageContentCollection *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","createContentCollection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(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( "", "Ogre::String const &","createContentCollection", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createContentCollection", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PageContentCollection *)(arg1)->createContentCollection((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_destroyContentCollection(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::PageContentCollection *arg2 = (Ogre::PageContentCollection *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","destroyContentCollection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","destroyContentCollection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentCollection * >(argp2);
  (arg1)->destroyContentCollection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_destroyAllContentCollections(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","destroyAllContentCollections", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  (arg1)->destroyAllContentCollections();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_getContentCollectionCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","getContentCollectionCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = ((Ogre::Page const *)arg1)->getContentCollectionCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_getContentCollection(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  size_t arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  Ogre::PageContentCollection *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","getContentCollection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getContentCollection", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  result = (Ogre::PageContentCollection *)(arg1)->getContentCollection(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_getContentCollectionList(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Page::ContentCollectionList *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","getContentCollectionList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (Ogre::Page::ContentCollectionList *) &((Ogre::Page const *)arg1)->getContentCollectionList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_canHandleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","canHandleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","canHandleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_handleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::WorkQueue::Response *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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","handleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","handleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_canHandleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","canHandleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","canHandleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_handleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","handleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","handleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page__notifyModified(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page *","_notifyModified", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  (arg1)->_notifyModified();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_isModified(int argc, VALUE *argv, VALUE self) {
  Ogre::Page *arg1 = (Ogre::Page *) 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_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Page const *","isModified", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Page * >(argp1);
  result = (bool)((Ogre::Page const *)arg1)->isModified();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Page_WORKQUEUE_PREPARE_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Page::WORKQUEUE_PREPARE_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_Page_WORKQUEUE_CHANGECOLLECTION_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Page::WORKQUEUE_CHANGECOLLECTION_REQUEST));
  return _val;
}


swig_class SwigClassPageContent;

SWIGINTERN void
free_Ogre_PageContent(Ogre::PageContent *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageContent_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager *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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  result = (Ogre::PageManager *)((Ogre::PageContent const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::PageContent const *)arg1)->getSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent__notifyAttached(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  Ogre::PageContentCollection *arg2 = (Ogre::PageContentCollection *) 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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentCollection * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  result = (Ogre::String *) &((Ogre::PageContent const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_save(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_frameStart(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","frameStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameStart(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_frameEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","frameEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->notifyCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_prepare(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->prepare(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_load(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContent_unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContent *arg1 = (Ogre::PageContent *) 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_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContent *","unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContent * >(argp1);
  (arg1)->unprepare();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPageContentCollection;

SWIGINTERN VALUE
_wrap_PageContentCollection_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::PageContentCollection::CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::PageContentCollection::CHUNK_VERSION));
  return _val;
}


SWIGINTERN void
free_Ogre_PageContentCollection(Ogre::PageContentCollection *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageContentCollection_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager *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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  result = (Ogre::PageManager *)((Ogre::PageContentCollection const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_getParentPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Page *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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection const *","getParentPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  result = (Ogre::Page *)((Ogre::PageContentCollection const *)arg1)->getParentPage();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Page, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::PageContentCollection const *)arg1)->getSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection const *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  result = (Ogre::String *) &((Ogre::PageContentCollection const *)arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection__notifyAttached(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","_notifyAttached", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_notifyAttached", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  (arg1)->_notifyAttached(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_save(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_frameStart(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","frameStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameStart(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_frameEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","frameEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->notifyCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_prepare(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->prepare(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_load(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollection_unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollection *arg1 = (Ogre::PageContentCollection *) 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_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollection * >(argp1);
  (arg1)->unprepare();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPageContentCollectionFactory;

SWIGINTERN void
free_Ogre_PageContentCollectionFactory(Ogre::PageContentCollectionFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageContentCollectionFactory_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollectionFactory *arg1 = (Ogre::PageContentCollectionFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollectionFactory const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollectionFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::PageContentCollectionFactory const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollectionFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollectionFactory *arg1 = (Ogre::PageContentCollectionFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageContentCollection *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_Ogre__PageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollectionFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollectionFactory * >(argp1);
  result = (Ogre::PageContentCollection *)(arg1)->createInstance();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentCollectionFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollectionFactory *arg1 = (Ogre::PageContentCollectionFactory *) 0 ;
  Ogre::PageContentCollection *arg2 = (Ogre::PageContentCollection *) 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_Ogre__PageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollectionFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollectionFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentCollection * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPageContentFactory;

SWIGINTERN void
free_Ogre_PageContentFactory(Ogre::PageContentFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageContentFactory_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentFactory *arg1 = (Ogre::PageContentFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PageContentFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentFactory const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::PageContentFactory const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentFactory *arg1 = (Ogre::PageContentFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageContent *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_Ogre__PageContentFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentFactory * >(argp1);
  result = (Ogre::PageContent *)(arg1)->createInstance();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageContentFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentFactory *arg1 = (Ogre::PageContentFactory *) 0 ;
  Ogre::PageContent *arg2 = (Ogre::PageContent *) 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_Ogre__PageContentFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContent *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContent * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPageProvider;

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

SWIGINTERN VALUE
_wrap_new_PageProvider(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PageProvider";
  Ogre::PageProvider *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PageProvider *)new Ogre::PageProvider();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PageProvider(Ogre::PageProvider *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageProvider_prepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","prepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","prepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","prepareProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->prepareProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageProvider_loadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","loadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","loadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","loadProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->loadProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageProvider_unloadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","unloadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","unloadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","unloadProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->unloadProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageProvider_unprepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","unprepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","unprepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","unprepareProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->unprepareProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageProvider_readWorldStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::StreamSerialiser *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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","readWorldStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(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( "", "Ogre::String const &","readWorldStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","readWorldStream", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::StreamSerialiser *)(arg1)->readWorldStream((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageProvider_writeWorldStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::StreamSerialiser *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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","writeWorldStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(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( "", "Ogre::String const &","writeWorldStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","writeWorldStream", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::StreamSerialiser *)(arg1)->writeWorldStream((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageProvider_readPageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","readPageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","readPageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","readPageStream", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::StreamSerialiser *)(arg1)->readPageStream(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageProvider_writePageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageProvider *arg1 = (Ogre::PageProvider *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageProvider *","writePageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageProvider * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","writePageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","writePageStream", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::StreamSerialiser *)(arg1)->writePageStream(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPageManager;

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

SWIGINTERN VALUE
_wrap_new_PageManager(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::PageManager";
  Ogre::PageManager *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::PageManager *)new Ogre::PageManager();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_PageManager(Ogre::PageManager *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PageManager_createWorld__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PagedWorld *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","createWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","createWorld", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createWorld", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PagedWorld *)(arg1)->createWorld((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_createWorld__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PagedWorld *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","createWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PagedWorld *)(arg1)->createWorld();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_createWorld(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_Ogre__PageManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_PageManager_createWorld__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PageManager, 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_PageManager_createWorld__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PageManager.createWorld", 
    "    Ogre::PagedWorld * PageManager.createWorld(Ogre::String const &name)\n"
    "    Ogre::PagedWorld * PageManager.createWorld()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_destroyWorld__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","destroyWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","destroyWorld", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroyWorld", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroyWorld((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_destroyWorld__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","destroyWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","destroyWorld", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  (arg1)->destroyWorld(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_destroyWorld(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_Ogre__PageManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PageManager_destroyWorld__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PageManager, 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_PageManager_destroyWorld__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PageManager.destroyWorld", 
    "    void PageManager.destroyWorld(Ogre::String const &name)\n"
    "    void PageManager.destroyWorld(Ogre::PagedWorld *world)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_loadWorld__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::PagedWorld *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","loadWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","loadWorld", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadWorld", 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 &","loadWorld", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadWorld", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  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_PageManager_loadWorld__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PagedWorld *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","loadWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","loadWorld", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadWorld", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_loadWorld__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::PagedWorld *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","loadWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","loadWorld", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","loadWorld", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","loadWorld", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadWorld", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::DataStreamPtr const &)*arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_loadWorld__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::PagedWorld *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","loadWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","loadWorld", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","loadWorld", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  result = (Ogre::PagedWorld *)(arg1)->loadWorld((Ogre::DataStreamPtr const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_loadWorld(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_Ogre__PageManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PageManager_loadWorld__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PageManager, 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_PageManager_loadWorld__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PageManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_PageManager_loadWorld__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PageManager, 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_PageManager_loadWorld__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PageManager.loadWorld", 
    "    Ogre::PagedWorld * PageManager.loadWorld(Ogre::String const &filename, Ogre::String const &name)\n"
    "    Ogre::PagedWorld * PageManager.loadWorld(Ogre::String const &filename)\n"
    "    Ogre::PagedWorld * PageManager.loadWorld(Ogre::DataStreamPtr const &stream, Ogre::String const &name)\n"
    "    Ogre::PagedWorld * PageManager.loadWorld(Ogre::DataStreamPtr const &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_saveWorld__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","saveWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","saveWorld", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  {
    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 &","saveWorld", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","saveWorld", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->saveWorld(arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_saveWorld__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::DataStreamPtr *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","saveWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","saveWorld", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","saveWorld", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","saveWorld", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::DataStreamPtr * >(argp3);
  (arg1)->saveWorld(arg2,(Ogre::DataStreamPtr const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PageManager_saveWorld(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 == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PageManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PageManager_saveWorld__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PageManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 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_PageManager_saveWorld__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PageManager.saveWorld", 
    "    void PageManager.saveWorld(Ogre::PagedWorld *world, Ogre::String const &filename)\n"
    "    void PageManager.saveWorld(Ogre::PagedWorld *world, Ogre::DataStreamPtr const &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getWorld(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PagedWorld *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","getWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","getWorld", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getWorld", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PagedWorld *)(arg1)->getWorld((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getWorlds(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager::WorldMap *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getWorlds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PageManager::WorldMap *) &((Ogre::PageManager const *)arg1)->getWorlds();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_addStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageStrategy *arg2 = (Ogre::PageStrategy *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","addStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","addStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategy * >(argp2);
  (arg1)->addStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_removeStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageStrategy *arg2 = (Ogre::PageStrategy *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","removeStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","removeStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategy * >(argp2);
  (arg1)->removeStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PageStrategy *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","getStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","getStrategy", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getStrategy", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PageStrategy *)(arg1)->getStrategy((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getStrategies(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager::StrategyMap *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getStrategies", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PageManager::StrategyMap *) &((Ogre::PageManager const *)arg1)->getStrategies();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_addContentCollectionFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageContentCollectionFactory *arg2 = (Ogre::PageContentCollectionFactory *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","addContentCollectionFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentCollectionFactory *","addContentCollectionFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentCollectionFactory * >(argp2);
  (arg1)->addContentCollectionFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_removeContentCollectionFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageContentCollectionFactory *arg2 = (Ogre::PageContentCollectionFactory *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","removeContentCollectionFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentCollectionFactory *","removeContentCollectionFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentCollectionFactory * >(argp2);
  (arg1)->removeContentCollectionFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getContentCollectionFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PageContentCollectionFactory *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","getContentCollectionFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","getContentCollectionFactory", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getContentCollectionFactory", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PageContentCollectionFactory *)(arg1)->getContentCollectionFactory((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollectionFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_createContentCollection(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PageContentCollection *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","createContentCollection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","createContentCollection", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createContentCollection", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PageContentCollection *)(arg1)->createContentCollection((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_destroyContentCollection(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageContentCollection *arg2 = (Ogre::PageContentCollection *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","destroyContentCollection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","destroyContentCollection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentCollection * >(argp2);
  (arg1)->destroyContentCollection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getContentCollectionFactories(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager::ContentCollectionFactoryMap *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getContentCollectionFactories", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PageManager::ContentCollectionFactoryMap *) &((Ogre::PageManager const *)arg1)->getContentCollectionFactories();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_addContentFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageContentFactory *arg2 = (Ogre::PageContentFactory *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","addContentFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentFactory *","addContentFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentFactory * >(argp2);
  (arg1)->addContentFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_removeContentFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageContentFactory *arg2 = (Ogre::PageContentFactory *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","removeContentFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentFactory *","removeContentFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentFactory * >(argp2);
  (arg1)->removeContentFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getContentFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PageContentFactory *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","getContentFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","getContentFactory", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getContentFactory", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PageContentFactory *)(arg1)->getContentFactory((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getContentFactories(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager::ContentFactoryMap *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getContentFactories", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PageManager::ContentFactoryMap *) &((Ogre::PageManager const *)arg1)->getContentFactories();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_createContent(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PageContent *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","createContent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","createContent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createContent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PageContent *)(arg1)->createContent((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_destroyContent(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageContent *arg2 = (Ogre::PageContent *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","destroyContent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContent *","destroyContent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContent * >(argp2);
  (arg1)->destroyContent(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_addWorldSectionFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PagedWorldSectionFactory *arg2 = (Ogre::PagedWorldSectionFactory *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","addWorldSectionFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorldSectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorldSectionFactory *","addWorldSectionFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorldSectionFactory * >(argp2);
  (arg1)->addWorldSectionFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_removeWorldSectionFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PagedWorldSectionFactory *arg2 = (Ogre::PagedWorldSectionFactory *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","removeWorldSectionFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorldSectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorldSectionFactory *","removeWorldSectionFactory", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorldSectionFactory * >(argp2);
  (arg1)->removeWorldSectionFactory(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getWorldSectionFactory(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PagedWorldSectionFactory *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","getWorldSectionFactory", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","getWorldSectionFactory", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getWorldSectionFactory", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PagedWorldSectionFactory *)(arg1)->getWorldSectionFactory((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSectionFactory, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_createWorldSection(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::PagedWorld *arg4 = (Ogre::PagedWorld *) 0 ;
  Ogre::SceneManager *arg5 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  Ogre::PagedWorldSection *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","createWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","createWorldSection", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createWorldSection", 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 &","createWorldSection", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createWorldSection", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createWorldSection", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::PagedWorld * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createWorldSection", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::SceneManager * >(argp5);
  result = (Ogre::PagedWorldSection *)(arg1)->createWorldSection((Ogre::String const &)*arg2,(Ogre::String const &)*arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  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_PageManager_destroyWorldSection(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PagedWorldSection *arg2 = (Ogre::PagedWorldSection *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","destroyWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","destroyWorldSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorldSection * >(argp2);
  (arg1)->destroyWorldSection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getWorldSectionFactories(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager::WorldSectionFactoryMap *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getWorldSectionFactories", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PageManager::WorldSectionFactoryMap *) &((Ogre::PageManager const *)arg1)->getWorldSectionFactories();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_setPageProvider(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageProvider *arg2 = (Ogre::PageProvider *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","setPageProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageProvider *","setPageProvider", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageProvider * >(argp2);
  (arg1)->setPageProvider(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getPageProvider(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageProvider *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getPageProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PageProvider *)((Ogre::PageManager const *)arg1)->getPageProvider();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__prepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_prepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_prepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_prepareProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_prepareProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__loadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_loadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_loadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_loadProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_loadProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__unloadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_unloadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_unloadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_unloadProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_unloadProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__unprepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_unprepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_unprepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_unprepareProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_unprepareProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__readPageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_readPageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","_readPageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_readPageStream", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::StreamSerialiser *)(arg1)->_readPageStream(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__writePageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_writePageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","_writePageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_writePageStream", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::StreamSerialiser *)(arg1)->_writePageStream(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__readWorldStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::StreamSerialiser *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_readWorldStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","_readWorldStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_readWorldStream", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::StreamSerialiser *)(arg1)->_readWorldStream((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager__writeWorldStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::StreamSerialiser *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","_writeWorldStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","_writeWorldStream", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_writeWorldStream", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::StreamSerialiser *)(arg1)->_writeWorldStream((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getPageResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getPageResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::String *) &((Ogre::PageManager const *)arg1)->getPageResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_setPageResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","setPageResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(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( "", "Ogre::String const &","setPageResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setPageResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setPageResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_addCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","addCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","addCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->addCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_removeCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","removeCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","removeCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->removeCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_hasCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","hasCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","hasCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  result = (bool)((Ogre::PageManager const *)arg1)->hasCamera(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getCameraList(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager::CameraList *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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getCameraList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::PageManager::CameraList *) &((Ogre::PageManager const *)arg1)->getCameraList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_setDebugDisplayLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","setDebugDisplayLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setDebugDisplayLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setDebugDisplayLevel(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getDebugDisplayLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getDebugDisplayLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::uint8)((Ogre::PageManager const *)arg1)->getDebugDisplayLevel();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_setPagingOperationsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","setPagingOperationsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setPagingOperationsEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setPagingOperationsEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PageManager_getPagingOperationsEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 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_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager const *","getPagingOperationsEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (bool)((Ogre::PageManager const *)arg1)->getPagingOperationsEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPagedWorld;

SWIGINTERN VALUE
_wrap_PagedWorld_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::PagedWorld::CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PagedWorld_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::PagedWorld::CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_PagedWorld_CHUNK_SECTIONDECLARATION_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::PagedWorld::CHUNK_SECTIONDECLARATION_ID));
  return _val;
}


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

SWIGINTERN VALUE
_wrap_new_PagedWorld(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::PageManager *arg2 = (Ogre::PageManager *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PagedWorld";
  Ogre::PagedWorld *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::PagedWorld", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PagedWorld", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageManager *","Ogre::PagedWorld", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageManager * >(argp2);
  result = (Ogre::PagedWorld *)new Ogre::PagedWorld((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_PagedWorld(Ogre::PagedWorld *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PagedWorld_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  result = (Ogre::String *) &((Ogre::PagedWorld const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  result = (Ogre::PageManager *)((Ogre::PagedWorld const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->load((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->load((Ogre::DataStreamPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->load(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorld_load(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_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorld_load__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorld_load__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 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_PagedWorld_load__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorld.load", 
    "    bool PagedWorld.load(Ogre::String const &filename)\n"
    "    bool PagedWorld.load(Ogre::DataStreamPtr const &stream)\n"
    "    bool PagedWorld.load(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_save__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(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( "", "Ogre::String const &","save", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","save", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->save((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_save__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr const &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr const &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->save((Ogre::DataStreamPtr const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_save__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorld_save(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_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorld_save__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorld_save__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 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_PagedWorld_save__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorld.save", 
    "    void PagedWorld.save(Ogre::String const &filename)\n"
    "    void PagedWorld.save(Ogre::DataStreamPtr const &stream)\n"
    "    void PagedWorld.save(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_createSection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg3 = 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  {
    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 &","createSection", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSection", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createSection", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSection", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,(Ogre::String const &)*arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_createSection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  {
    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 &","createSection", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSection", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,(Ogre::String const &)*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res3)) delete arg3;
  return vresult;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_createSection__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(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( "", "Ogre::String const &","createSection", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSection", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createSection", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSection", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::PagedWorldSection *)(arg1)->createSection((Ogre::String const &)*arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_createSection__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(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( "", "Ogre::String const &","createSection", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSection", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  result = (Ogre::PagedWorldSection *)(arg1)->createSection((Ogre::String const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_createSection__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::PageStrategy *arg2 = (Ogre::PageStrategy *) 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","createSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategy * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","createSection", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createSection", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,arg3,(Ogre::String const &)*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res4)) delete arg4;
  return vresult;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_createSection__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::PageStrategy *arg2 = (Ogre::PageStrategy *) 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","createSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategy * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  result = (Ogre::PagedWorldSection *)(arg1)->createSection(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorld_createSection(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_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneManager, 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_PagedWorld_createSection__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PageStrategy, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PagedWorld_createSection__SWIG_5(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_PagedWorld_createSection__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        int res = SWIG_AsPtr_std_string(argv[2], (std::string**)(0));
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PagedWorld_createSection__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PageStrategy, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PagedWorld_createSection__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      int res = SWIG_AsPtr_std_string(argv[1], (std::string**)(0));
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_PagedWorld_createSection__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "PagedWorld.createSection", 
    "    Ogre::PagedWorldSection * PagedWorld.createSection(Ogre::SceneManager *sceneMgr, Ogre::String const &typeName, Ogre::String const &sectionName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.createSection(Ogre::SceneManager *sceneMgr, Ogre::String const &typeName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.createSection(Ogre::String const &strategyName, Ogre::SceneManager *sceneMgr, Ogre::String const &sectionName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.createSection(Ogre::String const &strategyName, Ogre::SceneManager *sceneMgr)\n"
    "    Ogre::PagedWorldSection * PagedWorld.createSection(Ogre::PageStrategy *strategy, Ogre::SceneManager *sceneMgr, Ogre::String const &sectionName)\n"
    "    Ogre::PagedWorldSection * PagedWorld.createSection(Ogre::PageStrategy *strategy, Ogre::SceneManager *sceneMgr)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_destroySection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","destroySection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(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( "", "Ogre::String const &","destroySection", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","destroySection", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->destroySection((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_destroySection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::PagedWorldSection *arg2 = (Ogre::PagedWorldSection *) 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","destroySection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","destroySection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorldSection * >(argp2);
  (arg1)->destroySection(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorld_destroySection(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_Ogre__PagedWorld, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorldSection, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorld_destroySection__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 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_PagedWorld_destroySection__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorld.destroySection", 
    "    void PagedWorld.destroySection(Ogre::String const &name)\n"
    "    void PagedWorld.destroySection(Ogre::PagedWorldSection *sec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_destroyAllSections(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","destroyAllSections", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  (arg1)->destroyAllSections();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_getSectionCount(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld const *","getSectionCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  result = ((Ogre::PagedWorld const *)arg1)->getSectionCount();
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_getSection(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","getSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(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( "", "Ogre::String const &","getSection", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","getSection", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PagedWorldSection *)(arg1)->getSection((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_getSections(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PagedWorld::SectionMap *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld const *","getSections", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  result = (Ogre::PagedWorld::SectionMap *) &((Ogre::PagedWorld const *)arg1)->getSections();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_setPageProvider(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::PageProvider *arg2 = (Ogre::PageProvider *) 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","setPageProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageProvider *","setPageProvider", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageProvider * >(argp2);
  (arg1)->setPageProvider(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_getPageProvider(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageProvider *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld const *","getPageProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  result = (Ogre::PageProvider *)((Ogre::PagedWorld const *)arg1)->getPageProvider();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld__prepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","_prepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_prepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_prepareProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_prepareProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld__loadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","_loadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_loadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_loadProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_loadProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld__unloadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","_unloadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_unloadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_unloadProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_unloadProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld__unprepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","_unprepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_unprepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_unprepareProceduralPage", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (bool)(arg1)->_unprepareProceduralPage(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld__readPageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","_readPageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","_readPageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_readPageStream", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::StreamSerialiser *)(arg1)->_readPageStream(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld__writePageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::PageID arg2 ;
  Ogre::PagedWorldSection *arg3 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","_writePageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","_writePageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_writePageStream", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorldSection * >(argp3);
  result = (Ogre::StreamSerialiser *)(arg1)->_writePageStream(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_frameStart(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","frameStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameStart(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_frameEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","frameEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorld_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorld *arg1 = (Ogre::PagedWorld *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorld * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->notifyCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassPagedWorldSection;

SWIGINTERN VALUE
_wrap_PagedWorldSection_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::PagedWorldSection::CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::PagedWorldSection::CHUNK_VERSION));
  return _val;
}


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

SWIGINTERN VALUE
_wrap_new_PagedWorldSection(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::PagedWorldSection";
  Ogre::PagedWorldSection *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::PagedWorldSection", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::PagedWorldSection", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","Ogre::PagedWorldSection", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::PagedWorldSection", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  result = (Ogre::PagedWorldSection *)new Ogre::PagedWorldSection((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_PagedWorldSection(Ogre::PagedWorldSection *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PagedWorldSection_getManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageManager *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::PageManager *)((Ogre::PagedWorldSection const *)arg1)->getManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::String *) &((Ogre::PagedWorldSection const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageStrategy *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::PageStrategy *)((Ogre::PagedWorldSection const *)arg1)->getStrategy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_setStrategy__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageStrategy *arg2 = (Ogre::PageStrategy *) 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","setStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageStrategy, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageStrategy *","setStrategy", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageStrategy * >(argp2);
  (arg1)->setStrategy(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_setStrategy__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","setStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(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( "", "Ogre::String const &","setStrategy", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setStrategy", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setStrategy((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_setStrategy(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_Ogre__PagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PageStrategy, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorldSection_setStrategy__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorldSection, 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_PagedWorldSection_setStrategy__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorldSection.setStrategy", 
    "    void PagedWorldSection.setStrategy(Ogre::PageStrategy *strat)\n"
    "    void PagedWorldSection.setStrategy(Ogre::String const &stratName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_setSceneManager__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","setSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","setSceneManager", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->setSceneManager(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_setSceneManager__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","setSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(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( "", "Ogre::String const &","setSceneManager", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setSceneManager", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setSceneManager((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_setSceneManager(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_Ogre__PagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorldSection_setSceneManager__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorldSection, 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_PagedWorldSection_setSceneManager__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "PagedWorldSection.setSceneManager", 
    "    void PagedWorldSection.setSceneManager(Ogre::SceneManager *sm)\n"
    "    void PagedWorldSection.setSceneManager(Ogre::String const &smName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::PagedWorldSection const *)arg1)->getSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getWorld(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PagedWorld *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getWorld", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::PagedWorld *)((Ogre::PagedWorldSection const *)arg1)->getWorld();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getStrategyData(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageStrategyData *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getStrategyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::PageStrategyData *)((Ogre::PagedWorldSection const *)arg1)->getStrategyData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_setBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::AxisAlignedBox *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","setBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","setBoundingBox", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","setBoundingBox", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  (arg1)->setBoundingBox((Ogre::AxisAlignedBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getBoundingBox(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getBoundingBox", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::PagedWorldSection const *)arg1)->getBoundingBox();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_load(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->load(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_save(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_frameStart(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","frameStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameStart(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_frameEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","frameEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->notifyCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_loadOrCreatePage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Page *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","loadOrCreatePage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(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 &","loadOrCreatePage", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","loadOrCreatePage", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::Page *)(arg1)->loadOrCreatePage((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Page, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getPageID(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::PageID 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","getPageID", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(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 &","getPageID", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getPageID", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (Ogre::PageID)(arg1)->getPageID((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_loadPage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","loadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","loadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","loadPage", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->loadPage(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_loadPage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","loadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","loadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  (arg1)->loadPage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_loadPage(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_Ogre__PagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PagedWorldSection_loadPage__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorldSection, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PagedWorldSection_loadPage__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PagedWorldSection.loadPage", 
    "    void PagedWorldSection.loadPage(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void PagedWorldSection.loadPage(Ogre::PageID pageID)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_unloadPage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","unloadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","unloadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","unloadPage", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->unloadPage(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_unloadPage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","unloadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","unloadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  (arg1)->unloadPage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_unloadPage__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","unloadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","unloadPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","unloadPage", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->unloadPage(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_unloadPage__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","unloadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","unloadPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  (arg1)->unloadPage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_PagedWorldSection_unloadPage(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_Ogre__PagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Page, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_PagedWorldSection_unloadPage__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_PagedWorldSection_unloadPage__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Page, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PagedWorldSection_unloadPage__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__PagedWorldSection, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_PagedWorldSection_unloadPage__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "PagedWorldSection.unloadPage", 
    "    void PagedWorldSection.unloadPage(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void PagedWorldSection.unloadPage(Ogre::PageID pageID)\n"
    "    void PagedWorldSection.unloadPage(Ogre::Page *p, bool forceSynchronous)\n"
    "    void PagedWorldSection.unloadPage(Ogre::Page *p)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection__prepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_prepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_prepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  result = (bool)(arg1)->_prepareProceduralPage(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection__loadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_loadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_loadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  result = (bool)(arg1)->_loadProceduralPage(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection__unloadProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_unloadProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_unloadProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  result = (bool)(arg1)->_unloadProceduralPage(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection__unprepareProceduralPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::Page *arg2 = (Ogre::Page *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_unprepareProceduralPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Page, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Page *","_unprepareProceduralPage", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Page * >(argp2);
  result = (bool)(arg1)->_unprepareProceduralPage(arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_holdPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","holdPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","holdPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  (arg1)->holdPage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getPage(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::Page *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","getPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","getPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  result = (Ogre::Page *)(arg1)->getPage(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Page, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_removeAllPages(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","removeAllPages", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  (arg1)->removeAllPages();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_setPageProvider(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageProvider *arg2 = (Ogre::PageProvider *) 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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","setPageProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageProvider *","setPageProvider", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageProvider * >(argp2);
  (arg1)->setPageProvider(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getPageProvider(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageProvider *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection const *","getPageProvider", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::PageProvider *)((Ogre::PagedWorldSection const *)arg1)->getPageProvider();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageProvider, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection__readPageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_readPageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","_readPageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  result = (Ogre::StreamSerialiser *)(arg1)->_readPageStream(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection__writePageStream(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  Ogre::PageID arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  Ogre::StreamSerialiser *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","_writePageStream", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","_writePageStream", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  result = (Ogre::StreamSerialiser *)(arg1)->_writePageStream(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__StreamSerialiser, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSection_getType(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSection *arg1 = (Ogre::PagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","getType", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSection * >(argp1);
  result = (Ogre::String *) &(arg1)->getType();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassPagedWorldSectionFactory;

SWIGINTERN void
free_Ogre_PagedWorldSectionFactory(Ogre::PagedWorldSectionFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_PagedWorldSectionFactory_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSectionFactory *arg1 = (Ogre::PagedWorldSectionFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__PagedWorldSectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSectionFactory const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSectionFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::PagedWorldSectionFactory const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSectionFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSectionFactory *arg1 = (Ogre::PagedWorldSectionFactory *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::PagedWorld *arg3 = (Ogre::PagedWorld *) 0 ;
  Ogre::SceneManager *arg4 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::PagedWorldSection *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_Ogre__PagedWorldSectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSectionFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSectionFactory * >(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( "", "Ogre::String const &","createInstance", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createInstance", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createInstance", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PagedWorld * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::SceneManager *","createInstance", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::SceneManager * >(argp4);
  result = (Ogre::PagedWorldSection *)(arg1)->createInstance((Ogre::String const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_PagedWorldSectionFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::PagedWorldSectionFactory *arg1 = (Ogre::PagedWorldSectionFactory *) 0 ;
  Ogre::PagedWorldSection *arg2 = (Ogre::PagedWorldSection *) 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_Ogre__PagedWorldSectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PagedWorldSectionFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::PagedWorldSectionFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorldSection *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorldSection * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassSimplePageContentCollection;

SWIGINTERN VALUE
_wrap_SimplePageContentCollection_SUBCLASS_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::SimplePageContentCollection::SUBCLASS_CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_SUBCLASS_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::SimplePageContentCollection::SUBCLASS_CHUNK_VERSION));
  return _val;
}


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

SWIGINTERN VALUE
_wrap_new_SimplePageContentCollection(int argc, VALUE *argv, VALUE self) {
  Ogre::PageContentCollectionFactory *arg1 = (Ogre::PageContentCollectionFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::SimplePageContentCollection";
  Ogre::SimplePageContentCollection *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__PageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageContentCollectionFactory *","Ogre::SimplePageContentCollection", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::PageContentCollectionFactory * >(argp1);
  result = (Ogre::SimplePageContentCollection *)new Ogre::SimplePageContentCollection(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimplePageContentCollection(Ogre::SimplePageContentCollection *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SimplePageContentCollection_createContent(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  Ogre::PageContent *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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","createContent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(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( "", "Ogre::String const &","createContent", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createContent", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (Ogre::PageContent *)(arg1)->createContent((Ogre::String const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_destroyContent(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  Ogre::PageContent *arg2 = (Ogre::PageContent *) 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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","destroyContent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContent, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContent *","destroyContent", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContent * >(argp2);
  (arg1)->destroyContent(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_getContentList(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SimplePageContentCollection::ContentList *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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection const *","getContentList", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  result = (Ogre::SimplePageContentCollection::ContentList *) &((Ogre::SimplePageContentCollection const *)arg1)->getContentList();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_save(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_frameStart(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","frameStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameStart(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_frameEnd(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","frameEnd", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","frameEnd", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->frameEnd(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_notifyCamera(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","notifyCamera", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera *","notifyCamera", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  (arg1)->notifyCamera(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_prepare(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->prepare(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_load(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollection_unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollection *arg1 = (Ogre::SimplePageContentCollection *) 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_Ogre__SimplePageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollection *","unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollection * >(argp1);
  (arg1)->unprepare();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassSimplePageContentCollectionFactory;

SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_FACTORY_NAME_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_std_string(static_cast< std::string >(Ogre::SimplePageContentCollectionFactory::FACTORY_NAME));
  return _val;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_FACTORY_NAME_set(VALUE self, VALUE _val) {
  {
    std::string *ptr = (std::string *)0;
    int res = SWIG_AsPtr_std_string(_val, &ptr);
    if (!SWIG_IsOK(res) || !ptr) {
      SWIG_exception_fail(SWIG_ArgError((ptr ? res : SWIG_TypeError)), "in variable '""Ogre::SimplePageContentCollectionFactory::FACTORY_NAME""' of type '""Ogre::String""'"); 
    }
    Ogre::SimplePageContentCollectionFactory::FACTORY_NAME = *ptr;
    if (SWIG_IsNewObj(res)) delete ptr;
  }
  return _val;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_SimplePageContentCollectionFactory(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::SimplePageContentCollectionFactory";
  Ogre::SimplePageContentCollectionFactory *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::SimplePageContentCollectionFactory *)new Ogre::SimplePageContentCollectionFactory();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_SimplePageContentCollectionFactory(Ogre::SimplePageContentCollectionFactory *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_getName(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollectionFactory *arg1 = (Ogre::SimplePageContentCollectionFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__SimplePageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollectionFactory const *","getName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollectionFactory * >(argp1);
  result = (Ogre::String *) &((Ogre::SimplePageContentCollectionFactory const *)arg1)->getName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_createInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollectionFactory *arg1 = (Ogre::SimplePageContentCollectionFactory *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PageContentCollection *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_Ogre__SimplePageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollectionFactory *","createInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollectionFactory * >(argp1);
  result = (Ogre::PageContentCollection *)(arg1)->createInstance();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_SimplePageContentCollectionFactory_destroyInstance(int argc, VALUE *argv, VALUE self) {
  Ogre::SimplePageContentCollectionFactory *arg1 = (Ogre::SimplePageContentCollectionFactory *) 0 ;
  Ogre::PageContentCollection *arg2 = (Ogre::PageContentCollection *) 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_Ogre__SimplePageContentCollectionFactory, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SimplePageContentCollectionFactory *","destroyInstance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::SimplePageContentCollectionFactory * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PageContentCollection, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PageContentCollection *","destroyInstance", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PageContentCollection * >(argp2);
  (arg1)->destroyInstance(arg2);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassTerrainGroup;

SWIGINTERN VALUE
_wrap_new_TerrainGroup__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  Ogre::Terrain::Alignment arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainGroup";
  Ogre::TerrainGroup *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::TerrainGroup", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::Alignment","Ogre::TerrainGroup", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::Terrain::Alignment >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::TerrainGroup", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  ecode4 = SWIG_AsVal_float(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","Ogre::TerrainGroup", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (Ogre::TerrainGroup *)new Ogre::TerrainGroup(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TerrainGroup__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainGroup";
  Ogre::TerrainGroup *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::TerrainGroup", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::TerrainGroup *)new Ogre::TerrainGroup(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TerrainGroup(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_new_TerrainGroup__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__SceneManager, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(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_new_TerrainGroup__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainGroup.new", 
    "    TerrainGroup.new(Ogre::SceneManager *sm, Ogre::Terrain::Alignment align, Ogre::uint16 terrainSize, Ogre::Real terrainWorldSize)\n"
    "    TerrainGroup.new(Ogre::SceneManager *sm)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainGroup(Ogre::TerrainGroup *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TerrainGroup_getDefaultImportSettings(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Terrain::ImportData *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","getDefaultImportSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::Terrain::ImportData *) &(arg1)->getDefaultImportSettings();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain__ImportData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Vector3 *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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 &","setOrigin", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setOrigin", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setOrigin((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getOrigin(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getOrigin", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::TerrainGroup const *)arg1)->getOrigin();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Terrain::Alignment 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::Terrain::Alignment)((Ogre::TerrainGroup const *)arg1)->getAlignment();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getTerrainWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getTerrainWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::Real)((Ogre::TerrainGroup const *)arg1)->getTerrainWorldSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setTerrainWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setTerrainWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setTerrainWorldSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setTerrainWorldSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getTerrainSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getTerrainSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::uint16)((Ogre::TerrainGroup const *)arg1)->getTerrainSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setTerrainSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setTerrainSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setTerrainSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setTerrainSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::TerrainGroup const *)arg1)->getSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setFilenameConvention(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setFilenameConvention", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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( "", "Ogre::String const &","setFilenameConvention", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFilenameConvention", 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 &","setFilenameConvention", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFilenameConvention", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->setFilenameConvention((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setFilenamePrefix(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setFilenamePrefix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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( "", "Ogre::String const &","setFilenamePrefix", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFilenamePrefix", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setFilenamePrefix((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setFilenameExtension(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setFilenameExtension", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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( "", "Ogre::String const &","setFilenameExtension", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setFilenameExtension", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setFilenameExtension((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getFilenamePrefix(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getFilenamePrefix", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::String *) &((Ogre::TerrainGroup const *)arg1)->getFilenamePrefix();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getFilenameExtension(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getFilenameExtension", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::String *) &((Ogre::TerrainGroup const *)arg1)->getFilenameExtension();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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( "", "Ogre::String const &","setResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (Ogre::String *) &((Ogre::TerrainGroup const *)arg1)->getResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->defineTerrain(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","defineTerrain", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->defineTerrain(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::Terrain::ImportData *arg4 = (Ogre::Terrain::ImportData *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Terrain__ImportData, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Terrain::ImportData const *","defineTerrain", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Terrain::ImportData * >(argp4);
  (arg1)->defineTerrain(arg2,arg3,(Ogre::Terrain::ImportData const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::Image *arg4 = (Ogre::Image *) 0 ;
  Ogre::Terrain::LayerInstanceList *arg5 = (Ogre::Terrain::LayerInstanceList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const *","defineTerrain", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Terrain::LayerInstanceList const *","defineTerrain", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Terrain::LayerInstanceList * >(argp5);
  (arg1)->defineTerrain(arg2,arg3,(Ogre::Image const *)arg4,(Ogre::Terrain::LayerInstanceList const *)arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::Image *arg4 = (Ogre::Image *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Image, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Image const *","defineTerrain", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Image * >(argp4);
  (arg1)->defineTerrain(arg2,arg3,(Ogre::Image const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  float *arg4 = (float *) 0 ;
  Ogre::Terrain::LayerInstanceList *arg5 = (Ogre::Terrain::LayerInstanceList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float const *","defineTerrain", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Terrain::LayerInstanceList const *","defineTerrain", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Terrain::LayerInstanceList * >(argp5);
  (arg1)->defineTerrain(arg2,arg3,(float const *)arg4,(Ogre::Terrain::LayerInstanceList const *)arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_6(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  float *arg4 = (float *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "float const *","defineTerrain", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< float * >(argp4);
  (arg1)->defineTerrain(arg2,arg3,(float const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_defineTerrain__SWIG_7(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","defineTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","defineTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","defineTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","defineTerrain", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","defineTerrain", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->defineTerrain(arg2,arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_defineTerrain(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TerrainGroup_defineTerrain__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Terrain__ImportData, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TerrainGroup_defineTerrain__SWIG_2(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TerrainGroup_defineTerrain__SWIG_4(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TerrainGroup_defineTerrain__SWIG_6(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(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_TerrainGroup_defineTerrain__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          int res = SWIG_AsPtr_std_string(argv[3], (std::string**)(0));
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_TerrainGroup_defineTerrain__SWIG_7(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Image, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TerrainGroup_defineTerrain__SWIG_3(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_float, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TerrainGroup_defineTerrain__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TerrainGroup.defineTerrain", 
    "    void TerrainGroup.defineTerrain(long x, long y)\n"
    "    void TerrainGroup.defineTerrain(long x, long y, float constantHeight)\n"
    "    void TerrainGroup.defineTerrain(long x, long y, Ogre::Terrain::ImportData const *importData)\n"
    "    void TerrainGroup.defineTerrain(long x, long y, Ogre::Image const *img, Ogre::Terrain::LayerInstanceList const *layers)\n"
    "    void TerrainGroup.defineTerrain(long x, long y, Ogre::Image const *img)\n"
    "    void TerrainGroup.defineTerrain(long x, long y, float const *pFloat, Ogre::Terrain::LayerInstanceList const *layers)\n"
    "    void TerrainGroup.defineTerrain(long x, long y, float const *pFloat)\n"
    "    void TerrainGroup.defineTerrain(long x, long y, Ogre::String const &filename)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_loadAllTerrains__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","loadAllTerrains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","loadAllTerrains", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->loadAllTerrains(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_loadAllTerrains__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","loadAllTerrains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  (arg1)->loadAllTerrains();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_loadAllTerrains(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TerrainGroup_loadAllTerrains__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TerrainGroup_loadAllTerrains__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainGroup.loadAllTerrains", 
    "    void TerrainGroup.loadAllTerrains(bool synchronous)\n"
    "    void TerrainGroup.loadAllTerrains()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_loadTerrain__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","loadTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","loadTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","loadTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","loadTerrain", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->loadTerrain(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_loadTerrain__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","loadTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","loadTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","loadTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->loadTerrain(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_loadTerrain(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TerrainGroup_loadTerrain__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_TerrainGroup_loadTerrain__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "TerrainGroup.loadTerrain", 
    "    void TerrainGroup.loadTerrain(long x, long y, bool synchronous)\n"
    "    void TerrainGroup.loadTerrain(long x, long y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_unloadTerrain(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","unloadTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","unloadTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","unloadTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->unloadTerrain(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_removeTerrain(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","removeTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","removeTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","removeTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  (arg1)->removeTerrain(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_removeAllTerrains(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","removeAllTerrains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  (arg1)->removeAllTerrains();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_saveAllTerrains__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","saveAllTerrains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","saveAllTerrains", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","saveAllTerrains", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->saveAllTerrains(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_saveAllTerrains__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","saveAllTerrains", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","saveAllTerrains", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->saveAllTerrains(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_saveAllTerrains(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TerrainGroup_saveAllTerrains__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TerrainGroup_saveAllTerrains__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainGroup.saveAllTerrains", 
    "    void TerrainGroup.saveAllTerrains(bool onlyIfModified, bool replaceManualFilenames)\n"
    "    void TerrainGroup.saveAllTerrains(bool onlyIfModified)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getTerrainDefinition(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  Ogre::TerrainGroup::TerrainSlotDefinition *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getTerrainDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getTerrainDefinition", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getTerrainDefinition", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (Ogre::TerrainGroup::TerrainSlotDefinition *)((Ogre::TerrainGroup const *)arg1)->getTerrainDefinition(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainGroup__TerrainSlotDefinition, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getTerrain(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  Ogre::Terrain *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getTerrain", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getTerrain", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (Ogre::Terrain *)((Ogre::TerrainGroup const *)arg1)->getTerrain(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_freeTemporaryResources(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","freeTemporaryResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  (arg1)->freeTemporaryResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_update__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","update", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->update(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_update__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  (arg1)->update();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_update(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TerrainGroup_update__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TerrainGroup_update__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainGroup.update", 
    "    void TerrainGroup.update(bool synchronous)\n"
    "    void TerrainGroup.update()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_updateGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","updateGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  (arg1)->updateGeometry();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_updateDerivedData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  bool arg2 ;
  Ogre::uint8 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","updateDerivedData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","updateDerivedData", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","updateDerivedData", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  (arg1)->updateDerivedData(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_updateDerivedData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","updateDerivedData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","updateDerivedData", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->updateDerivedData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_updateDerivedData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","updateDerivedData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  (arg1)->updateDerivedData();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_updateDerivedData(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TerrainGroup_updateDerivedData__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TerrainGroup_updateDerivedData__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TerrainGroup_updateDerivedData__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainGroup.updateDerivedData", 
    "    void TerrainGroup.updateDerivedData(bool synchronous, Ogre::uint8 typeMask)\n"
    "    void TerrainGroup.updateDerivedData(bool synchronous)\n"
    "    void TerrainGroup.updateDerivedData()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getHeightAtWorldPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Terrain **arg5 = (Ogre::Terrain **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  float result;
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","getHeightAtWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getHeightAtWorldPosition", 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","getHeightAtWorldPosition", 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","getHeightAtWorldPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Terrain **","getHeightAtWorldPosition", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Terrain ** >(argp5);
  result = (float)(arg1)->getHeightAtWorldPosition(arg2,arg3,arg4,arg5);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getHeightAtWorldPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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 ;
  float 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","getHeightAtWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getHeightAtWorldPosition", 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","getHeightAtWorldPosition", 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","getHeightAtWorldPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (float)(arg1)->getHeightAtWorldPosition(arg2,arg3,arg4);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getHeightAtWorldPosition__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Terrain **arg3 = (Ogre::Terrain **) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","getHeightAtWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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 &","getHeightAtWorldPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getHeightAtWorldPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Terrain **","getHeightAtWorldPosition", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Terrain ** >(argp3);
  result = (float)(arg1)->getHeightAtWorldPosition((Ogre::Vector3 const &)*arg2,arg3);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getHeightAtWorldPosition__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","getHeightAtWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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 &","getHeightAtWorldPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getHeightAtWorldPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (float)(arg1)->getHeightAtWorldPosition((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_getHeightAtWorldPosition(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_Ogre__TerrainGroup, 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_TerrainGroup_getHeightAtWorldPosition__SWIG_3(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 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_p_Ogre__Terrain, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TerrainGroup_getHeightAtWorldPosition__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 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_TerrainGroup_getHeightAtWorldPosition__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_p_Ogre__Terrain, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_TerrainGroup_getHeightAtWorldPosition__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "TerrainGroup.getHeightAtWorldPosition", 
    "    float TerrainGroup.getHeightAtWorldPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain **ppTerrain)\n"
    "    float TerrainGroup.getHeightAtWorldPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    float TerrainGroup.getHeightAtWorldPosition(Ogre::Vector3 const &pos, Ogre::Terrain **ppTerrain)\n"
    "    float TerrainGroup.getHeightAtWorldPosition(Ogre::Vector3 const &pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_rayIntersects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< Ogre::TerrainGroup::RayResult > 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","rayIntersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","rayIntersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","rayIntersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","rayIntersects", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = ((Ogre::TerrainGroup const *)arg1)->rayIntersects((Ogre::Ray const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new Ogre::TerrainGroup::RayResult(static_cast< const Ogre::TerrainGroup::RayResult& >(result))), SWIGTYPE_p_Ogre__TerrainGroup__RayResult, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_rayIntersects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< Ogre::TerrainGroup::RayResult > 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","rayIntersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","rayIntersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","rayIntersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  result = ((Ogre::TerrainGroup const *)arg1)->rayIntersects((Ogre::Ray const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::TerrainGroup::RayResult(static_cast< const Ogre::TerrainGroup::RayResult& >(result))), SWIGTYPE_p_Ogre__TerrainGroup__RayResult, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_rayIntersects(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainGroup_rayIntersects__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TerrainGroup_rayIntersects__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainGroup.rayIntersects", 
    "    Ogre::TerrainGroup::RayResult TerrainGroup.rayIntersects(Ogre::Ray const &ray, Ogre::Real distanceLimit)\n"
    "    Ogre::TerrainGroup::RayResult TerrainGroup.rayIntersects(Ogre::Ray const &ray)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_boxIntersects(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::AxisAlignedBox *arg2 = 0 ;
  Ogre::TerrainGroup::TerrainList *arg3 = (Ogre::TerrainGroup::TerrainList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","boxIntersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__AxisAlignedBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::AxisAlignedBox const &","boxIntersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::AxisAlignedBox const &","boxIntersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::AxisAlignedBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__vectorT_Ogre__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup::TerrainList *","boxIntersects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup::TerrainList * >(argp3);
  ((Ogre::TerrainGroup const *)arg1)->boxIntersects((Ogre::AxisAlignedBox const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_sphereIntersects(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Sphere *arg2 = 0 ;
  Ogre::TerrainGroup::TerrainList *arg3 = (Ogre::TerrainGroup::TerrainList *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","sphereIntersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Sphere,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Sphere const &","sphereIntersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Sphere const &","sphereIntersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Sphere * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__vectorT_Ogre__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup::TerrainList *","sphereIntersects", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup::TerrainList * >(argp3);
  ((Ogre::TerrainGroup const *)arg1)->sphereIntersects((Ogre::Sphere const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_convertWorldPositionToTerrainSlot(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  long *arg3 = (long *) 0 ;
  long *arg4 = (long *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","convertWorldPositionToTerrainSlot", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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 &","convertWorldPositionToTerrainSlot", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertWorldPositionToTerrainSlot", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "long *","convertWorldPositionToTerrainSlot", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< long * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "long *","convertWorldPositionToTerrainSlot", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< long * >(argp4);
  ((Ogre::TerrainGroup const *)arg1)->convertWorldPositionToTerrainSlot((Ogre::Vector3 const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_convertTerrainSlotToWorldPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","convertTerrainSlotToWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","convertTerrainSlotToWorldPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","convertTerrainSlotToWorldPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","convertTerrainSlotToWorldPosition", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  ((Ogre::TerrainGroup const *)arg1)->convertTerrainSlotToWorldPosition(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_isDerivedDataUpdateInProgress(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","isDerivedDataUpdateInProgress", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (bool)((Ogre::TerrainGroup const *)arg1)->isDerivedDataUpdateInProgress();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getTerrainIterator__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::MapIterator< Ogre::map< Ogre::uint32,TerrainSlot *,std::less< Ogre::uint32 >,Ogre::STLAllocator< std::pair< Ogre::uint32 const,TerrainSlot * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","getTerrainIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = (arg1)->getTerrainIterator();
  vresult = SWIG_NewPointerObj((new Ogre::TerrainGroup::TerrainIterator(static_cast< const Ogre::TerrainGroup::TerrainIterator& >(result))), SWIGTYPE_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_getTerrainIterator__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::ConstMapIterator< Ogre::map< Ogre::uint32,TerrainSlot *,std::less< Ogre::uint32 >,Ogre::STLAllocator< std::pair< Ogre::uint32 const,TerrainSlot * >,Ogre::GeneralAllocPolicy > >::type > > 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","getTerrainIterator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  result = ((Ogre::TerrainGroup const *)arg1)->getTerrainIterator();
  vresult = SWIG_NewPointerObj((new Ogre::TerrainGroup::ConstTerrainIterator(static_cast< const Ogre::TerrainGroup::ConstTerrainIterator& >(result))), SWIGTYPE_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_getTerrainIterator(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TerrainGroup_getTerrainIterator__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TerrainGroup_getTerrainIterator__SWIG_1(nargs, args, self);
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TerrainGroup.getTerrainIterator", 
    "    Ogre::TerrainGroup::ConstTerrainIterator TerrainGroup.getTerrainIterator()\n"
    "    Ogre::TerrainGroup::ConstTerrainIterator TerrainGroup.getTerrainIterator()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_canHandleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","canHandleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","canHandleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_handleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::WorkQueue::Response *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","handleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","handleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_canHandleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","canHandleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","canHandleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_handleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","handleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","handleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_packIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  Ogre::uint32 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","packIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","packIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","packIndex", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (Ogre::uint32)((Ogre::TerrainGroup const *)arg1)->packIndex(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_unpackIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::uint32 arg2 ;
  long *arg3 = (long *) 0 ;
  long *arg4 = (long *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","unpackIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","unpackIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "long *","unpackIndex", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< long * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_long, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "long *","unpackIndex", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< long * >(argp4);
  (arg1)->unpackIndex(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_generateFilename(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  Ogre::String 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup const *","generateFilename", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","generateFilename", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","generateFilename", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = ((Ogre::TerrainGroup const *)arg1)->generateFilename(arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_saveGroupDefinition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","saveGroupDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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( "", "Ogre::String const &","saveGroupDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","saveGroupDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->saveGroupDefinition((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_saveGroupDefinition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","saveGroupDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","saveGroupDefinition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","saveGroupDefinition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->saveGroupDefinition(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_saveGroupDefinition(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainGroup_saveGroupDefinition__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 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_TerrainGroup_saveGroupDefinition__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainGroup.saveGroupDefinition", 
    "    void TerrainGroup.saveGroupDefinition(Ogre::String const &filename)\n"
    "    void TerrainGroup.saveGroupDefinition(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_loadGroupDefinition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","loadGroupDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(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( "", "Ogre::String const &","loadGroupDefinition", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadGroupDefinition", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->loadGroupDefinition((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_loadGroupDefinition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","loadGroupDefinition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","loadGroupDefinition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","loadGroupDefinition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->loadGroupDefinition(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainGroup_loadGroupDefinition(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_Ogre__TerrainGroup, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainGroup_loadGroupDefinition__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 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_TerrainGroup_loadGroupDefinition__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainGroup.loadGroupDefinition", 
    "    void TerrainGroup.loadGroupDefinition(Ogre::String const &filename)\n"
    "    void TerrainGroup.loadGroupDefinition(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_WORKQUEUE_LOAD_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::TerrainGroup::WORKQUEUE_LOAD_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::TerrainGroup::CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::TerrainGroup::CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_setDefaultImportSettings(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","setDefaultImportSettings", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setDefaultImportSettings", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  Ogre_TerrainGroup_setDefaultImportSettings(arg1,arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGroup_initBlendMaps(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGroup *arg1 = (Ogre::TerrainGroup *) 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_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","initBlendMaps", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGroup * >(argp1);
  Ogre_TerrainGroup_initBlendMaps(arg1);
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassTerrainLayerBlendMap;

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

SWIGINTERN VALUE
_wrap_new_TerrainLayerBlendMap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::HardwarePixelBuffer *arg3 = (Ogre::HardwarePixelBuffer *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainLayerBlendMap";
  Ogre::TerrainLayerBlendMap *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","Ogre::TerrainLayerBlendMap", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::TerrainLayerBlendMap", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__HardwarePixelBuffer, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::HardwarePixelBuffer *","Ogre::TerrainLayerBlendMap", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::HardwarePixelBuffer * >(argp3);
  result = (Ogre::TerrainLayerBlendMap *)new Ogre::TerrainLayerBlendMap(arg1,arg2,arg3);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainLayerBlendMap(Ogre::TerrainLayerBlendMap *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Terrain *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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  result = (Ogre::Terrain *)((Ogre::TerrainLayerBlendMap const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_getLayerIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap const *","getLayerIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  result = (Ogre::uint8)((Ogre::TerrainLayerBlendMap const *)arg1)->getLayerIndex();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convertWorldToUVSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Real *arg3 = (Ogre::Real *) 0 ;
  Ogre::Real *arg4 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","convertWorldToUVSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(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 &","convertWorldToUVSpace", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertWorldToUVSpace", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Real *","convertWorldToUVSpace", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Real * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real *","convertWorldToUVSpace", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  (arg1)->convertWorldToUVSpace((Ogre::Vector3 const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convertUVToWorldSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","convertUVToWorldSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","convertUVToWorldSpace", 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","convertUVToWorldSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","convertUVToWorldSpace", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->convertUVToWorldSpace(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convertUVToImageSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  size_t *arg5 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","convertUVToImageSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","convertUVToImageSpace", 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","convertUVToImageSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_size_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "size_t *","convertUVToImageSpace", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< size_t * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_size_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "size_t *","convertUVToImageSpace", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< size_t * >(argp5);
  (arg1)->convertUVToImageSpace(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convertImageToUVSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::Real *arg4 = (Ogre::Real *) 0 ;
  Ogre::Real *arg5 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","convertImageToUVSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","convertImageToUVSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","convertImageToUVSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real *","convertImageToUVSpace", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real *","convertImageToUVSpace", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  (arg1)->convertImageToUVSpace(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convertImageToTerrainSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  Ogre::Real *arg4 = (Ogre::Real *) 0 ;
  Ogre::Real *arg5 = (Ogre::Real *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","convertImageToTerrainSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","convertImageToTerrainSpace", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","convertImageToTerrainSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Real *","convertImageToTerrainSpace", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Real * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_float, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Real *","convertImageToTerrainSpace", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Real * >(argp5);
  (arg1)->convertImageToTerrainSpace(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_convertTerrainToImageSpace(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  size_t *arg4 = (size_t *) 0 ;
  size_t *arg5 = (size_t *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","convertTerrainToImageSpace", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","convertTerrainToImageSpace", 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","convertTerrainToImageSpace", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_size_t, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "size_t *","convertTerrainToImageSpace", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< size_t * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_size_t, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "size_t *","convertTerrainToImageSpace", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< size_t * >(argp5);
  (arg1)->convertTerrainToImageSpace(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_getBlendValue(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  float 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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","getBlendValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","getBlendValue", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","getBlendValue", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  result = (float)(arg1)->getBlendValue(arg2,arg3);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_setBlendValue(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  size_t arg2 ;
  size_t arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  size_t val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","setBlendValue", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","setBlendValue", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  ecode3 = SWIG_AsVal_size_t(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "size_t","setBlendValue", 3, argv[1] ));
  } 
  arg3 = static_cast< size_t >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","setBlendValue", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setBlendValue(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_getBlendPointer(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float *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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","getBlendPointer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  result = (float *)(arg1)->getBlendPointer();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_dirty(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","dirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  (arg1)->dirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_dirtyRect(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::Rect *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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","dirtyRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","dirtyRect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","dirtyRect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->dirtyRect((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_blit__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::PixelBox *arg2 = 0 ;
  Ogre::Box *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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","blit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","blit", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","blit", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__Box,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Box const &","blit", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Box const &","blit", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Box * >(argp3);
  (arg1)->blit((Ogre::PixelBox const &)*arg2,(Ogre::Box const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_blit__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::PixelBox *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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","blit", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__PixelBox,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PixelBox const &","blit", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::PixelBox const &","blit", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::PixelBox * >(argp2);
  (arg1)->blit((Ogre::PixelBox const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainLayerBlendMap_blit(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_Ogre__TerrainLayerBlendMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainLayerBlendMap_blit__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainLayerBlendMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PixelBox, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Box, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_TerrainLayerBlendMap_blit__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainLayerBlendMap.blit", 
    "    void TerrainLayerBlendMap.blit(Ogre::PixelBox const &src, Ogre::Box const &dstBox)\n"
    "    void TerrainLayerBlendMap.blit(Ogre::PixelBox const &src)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_loadImage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::Image *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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Image,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Image const &","loadImage", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Image const &","loadImage", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Image * >(argp2);
  (arg1)->loadImage((Ogre::Image const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_loadImage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::DataStreamPtr *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadImage", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadImage", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  {
    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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->loadImage(*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_loadImage__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::DataStreamPtr *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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::DataStreamPtr &","loadImage", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::DataStreamPtr &","loadImage", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::DataStreamPtr * >(argp2);
  (arg1)->loadImage(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_loadImage__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","loadImage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(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( "", "Ogre::String const &","loadImage", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 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 &","loadImage", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","loadImage", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->loadImage((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainLayerBlendMap_loadImage(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_Ogre__TerrainLayerBlendMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Image, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainLayerBlendMap_loadImage__SWIG_0(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainLayerBlendMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainLayerBlendMap_loadImage__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainLayerBlendMap, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__DataStream_t, 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_TerrainLayerBlendMap_loadImage__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainLayerBlendMap, 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_TerrainLayerBlendMap_loadImage__SWIG_3(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainLayerBlendMap.loadImage", 
    "    void TerrainLayerBlendMap.loadImage(Ogre::Image const &img)\n"
    "    void TerrainLayerBlendMap.loadImage(Ogre::DataStreamPtr &stream, Ogre::String const &ext)\n"
    "    void TerrainLayerBlendMap.loadImage(Ogre::DataStreamPtr &stream)\n"
    "    void TerrainLayerBlendMap.loadImage(Ogre::String const &filename, Ogre::String const &groupName)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerBlendMap_update(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerBlendMap *arg1 = (Ogre::TerrainLayerBlendMap *) 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_Ogre__TerrainLayerBlendMap, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerBlendMap *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerBlendMap * >(argp1);
  (arg1)->update();
  return Qnil;
fail:
  return Qnil;
}


swig_class SwigClassTerrainLayerSamplerElement;

SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_source_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","source", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  if (arg1) (arg1)->source = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_source_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","source", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  result = (Ogre::uint8) ((arg1)->source);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_semantic_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  Ogre::TerrainLayerSamplerSemantic arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","semantic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerSemantic","semantic", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::TerrainLayerSamplerSemantic >(val2);
  if (arg1) (arg1)->semantic = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_semantic_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainLayerSamplerSemantic 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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","semantic", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  result = (Ogre::TerrainLayerSamplerSemantic) ((arg1)->semantic);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_elementStart_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","elementStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","elementStart", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  if (arg1) (arg1)->elementStart = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_elementStart_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","elementStart", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  result = (Ogre::uint8) ((arg1)->elementStart);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_elementCount_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","elementCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","elementCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  if (arg1) (arg1)->elementCount = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement_elementCount_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement *","elementCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  result = (Ogre::uint8) ((arg1)->elementCount);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerSamplerElement.==

  call-seq:
    ==(e) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_TerrainLayerSamplerElement___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSamplerElement *arg1 = (Ogre::TerrainLayerSamplerElement *) 0 ;
  Ogre::TerrainLayerSamplerElement *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_Ogre__TerrainLayerSamplerElement, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TerrainLayerSamplerElement,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElement const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TerrainLayerSamplerElement const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainLayerSamplerElement * >(argp2);
  result = (bool)((Ogre::TerrainLayerSamplerElement const *)arg1)->operator ==((Ogre::TerrainLayerSamplerElement const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TerrainLayerSamplerElement__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TerrainLayerSamplerElement";
  Ogre::TerrainLayerSamplerElement *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainLayerSamplerElement *)new Ogre::TerrainLayerSamplerElement();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TerrainLayerSamplerElement__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::uint8 arg1 ;
  Ogre::TerrainLayerSamplerSemantic arg2 ;
  Ogre::uint8 arg3 ;
  Ogre::uint8 arg4 ;
  unsigned char val1 ;
  int ecode1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  unsigned char val4 ;
  int ecode4 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainLayerSamplerElement";
  Ogre::TerrainLayerSamplerElement *result = 0 ;
  
  if ((argc < 4) || (argc > 4)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 4)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_char(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::TerrainLayerSamplerElement", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint8 >(val1);
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerSemantic","Ogre::TerrainLayerSamplerElement", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::TerrainLayerSamplerSemantic >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::TerrainLayerSamplerElement", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_char(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint8","Ogre::TerrainLayerSamplerElement", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::uint8 >(val4);
  result = (Ogre::TerrainLayerSamplerElement *)new Ogre::TerrainLayerSamplerElement(arg1,arg2,arg3,arg4);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TerrainLayerSamplerElement(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_TerrainLayerSamplerElement__SWIG_0(nargs, args, self);
  }
  if (argc == 4) {
    int _v;
    {
      int res = SWIG_AsVal_unsigned_SS_char(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_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_unsigned_SS_char(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_new_TerrainLayerSamplerElement__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainLayerSamplerElement.new", 
    "    TerrainLayerSamplerElement.new()\n"
    "    TerrainLayerSamplerElement.new(Ogre::uint8 src, Ogre::TerrainLayerSamplerSemantic sem, Ogre::uint8 elemStart, Ogre::uint8 elemCount)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainLayerSamplerElement(Ogre::TerrainLayerSamplerElement *arg1) {
    delete arg1;
}

swig_class SwigClassTerrainLayerSampler;

SWIGINTERN VALUE
_wrap_TerrainLayerSampler_alias_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSampler *arg1 = (Ogre::TerrainLayerSampler *) 0 ;
  Ogre::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_Ogre__TerrainLayerSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSampler *","alias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSampler * >(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( "", "Ogre::String const &","alias", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","alias", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  if (arg1) (arg1)->alias = *arg2;
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSampler_alias_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSampler *arg1 = (Ogre::TerrainLayerSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TerrainLayerSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSampler *","alias", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSampler * >(argp1);
  result = (Ogre::String *) & ((arg1)->alias);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSampler_format_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSampler *arg1 = (Ogre::TerrainLayerSampler *) 0 ;
  Ogre::PixelFormat arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainLayerSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSampler *","format", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSampler * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","format", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  if (arg1) (arg1)->format = arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerSampler_format_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSampler *arg1 = (Ogre::TerrainLayerSampler *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::PixelFormat 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_Ogre__TerrainLayerSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSampler *","format", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSampler * >(argp1);
  result = (Ogre::PixelFormat) ((arg1)->format);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerSampler.==

  call-seq:
    ==(s) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_TerrainLayerSampler___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerSampler *arg1 = (Ogre::TerrainLayerSampler *) 0 ;
  Ogre::TerrainLayerSampler *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_Ogre__TerrainLayerSampler, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSampler const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerSampler * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TerrainLayerSampler,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSampler const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TerrainLayerSampler const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainLayerSampler * >(argp2);
  result = (bool)((Ogre::TerrainLayerSampler const *)arg1)->operator ==((Ogre::TerrainLayerSampler const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_new_TerrainLayerSampler__SWIG_0(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TerrainLayerSampler";
  Ogre::TerrainLayerSampler *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainLayerSampler *)new Ogre::TerrainLayerSampler();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TerrainLayerSampler__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::PixelFormat arg2 ;
  int res1 = SWIG_OLDOBJ ;
  int val2 ;
  int ecode2 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainLayerSampler";
  Ogre::TerrainLayerSampler *result = 0 ;
  
  if ((argc < 2) || (argc > 2)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",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 &","Ogre::TerrainLayerSampler", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::TerrainLayerSampler", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  ecode2 = SWIG_AsVal_int(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PixelFormat","Ogre::TerrainLayerSampler", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::PixelFormat >(val2);
  result = (Ogre::TerrainLayerSampler *)new Ogre::TerrainLayerSampler((Ogre::String const &)*arg1,arg2);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN VALUE _wrap_new_TerrainLayerSampler(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_TerrainLayerSampler__SWIG_0(nargs, args, self);
  }
  if (argc == 2) {
    int _v;
    int res = SWIG_AsPtr_std_string(argv[0], (std::string**)(0));
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_new_TerrainLayerSampler__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 2, "TerrainLayerSampler.new", 
    "    TerrainLayerSampler.new()\n"
    "    TerrainLayerSampler.new(Ogre::String const &aliasName, Ogre::PixelFormat fmt)\n");
  
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainLayerSampler(Ogre::TerrainLayerSampler *arg1) {
    delete arg1;
}

swig_class SwigClassTerrainLayerDeclaration;

SWIGINTERN VALUE
_wrap_TerrainLayerDeclaration_samplers_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerDeclaration *arg1 = (Ogre::TerrainLayerDeclaration *) 0 ;
  Ogre::TerrainLayerSamplerList *arg2 = (Ogre::TerrainLayerSamplerList *) 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_Ogre__TerrainLayerDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration *","samplers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerList *","samplers", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainLayerSamplerList * >(argp2);
  if (arg1) (arg1)->samplers = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerDeclaration_samplers_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerDeclaration *arg1 = (Ogre::TerrainLayerDeclaration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainLayerSamplerList *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_Ogre__TerrainLayerDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration *","samplers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp1);
  result = (Ogre::TerrainLayerSamplerList *)& ((arg1)->samplers);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSampler_Ogre__STLAllocatorT_Ogre__TerrainLayerSampler_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerDeclaration_elements_set(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerDeclaration *arg1 = (Ogre::TerrainLayerDeclaration *) 0 ;
  Ogre::TerrainLayerSamplerElementList *arg2 = (Ogre::TerrainLayerSamplerElementList *) 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_Ogre__TerrainLayerDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration *","elements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerSamplerElementList *","elements", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainLayerSamplerElementList * >(argp2);
  if (arg1) (arg1)->elements = *arg2;
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainLayerDeclaration_elements_get(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerDeclaration *arg1 = (Ogre::TerrainLayerDeclaration *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainLayerSamplerElementList *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_Ogre__TerrainLayerDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration *","elements", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp1);
  result = (Ogre::TerrainLayerSamplerElementList *)& ((arg1)->elements);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__TerrainLayerSamplerElement_Ogre__STLAllocatorT_Ogre__TerrainLayerSamplerElement_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/*
  Document-method: Ogre::TerrainLayerDeclaration.==

  call-seq:
    ==(dcl) -> bool

Equality comparison operator.
*/
SWIGINTERN VALUE
_wrap_TerrainLayerDeclaration___eq__(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerDeclaration *arg1 = (Ogre::TerrainLayerDeclaration *) 0 ;
  Ogre::TerrainLayerDeclaration *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_Ogre__TerrainLayerDeclaration, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration const *","operator ==", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TerrainLayerDeclaration,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration const &","operator ==", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TerrainLayerDeclaration const &","operator ==", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp2);
  result = (bool)((Ogre::TerrainLayerDeclaration const *)arg1)->operator ==((Ogre::TerrainLayerDeclaration const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


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

SWIGINTERN VALUE
_wrap_new_TerrainLayerDeclaration(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TerrainLayerDeclaration";
  Ogre::TerrainLayerDeclaration *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainLayerDeclaration *)new Ogre::TerrainLayerDeclaration();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainLayerDeclaration(Ogre::TerrainLayerDeclaration *arg1) {
    delete arg1;
}

swig_class SwigClassTerrainMaterialGenerator;

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

SWIGINTERN VALUE
_wrap_new_TerrainMaterialGenerator(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TerrainMaterialGenerator";
  Ogre::TerrainMaterialGenerator *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainMaterialGenerator *)new Ogre::TerrainMaterialGenerator();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainMaterialGenerator(Ogre::TerrainMaterialGenerator *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_getProfiles(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainMaterialGenerator::ProfileList *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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator const *","getProfiles", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  result = (Ogre::TerrainMaterialGenerator::ProfileList *) &((Ogre::TerrainMaterialGenerator const *)arg1)->getProfiles();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__vectorT_Ogre__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_p_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_setActiveProfile__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","setActiveProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(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( "", "Ogre::String const &","setActiveProfile", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setActiveProfile", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setActiveProfile((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_setActiveProfile__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::TerrainMaterialGenerator::Profile *arg2 = (Ogre::TerrainMaterialGenerator::Profile *) 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","setActiveProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TerrainMaterialGenerator__Profile, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator::Profile *","setActiveProfile", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainMaterialGenerator::Profile * >(argp2);
  (arg1)->setActiveProfile(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainMaterialGenerator_setActiveProfile(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_Ogre__TerrainMaterialGenerator, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__TerrainMaterialGenerator__Profile, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainMaterialGenerator_setActiveProfile__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainMaterialGenerator, 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_TerrainMaterialGenerator_setActiveProfile__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainMaterialGenerator.setActiveProfile", 
    "    void TerrainMaterialGenerator.setActiveProfile(Ogre::String const &name)\n"
    "    void TerrainMaterialGenerator.setActiveProfile(Ogre::TerrainMaterialGenerator::Profile *p)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_getActiveProfile(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainMaterialGenerator::Profile *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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator const *","getActiveProfile", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  result = (Ogre::TerrainMaterialGenerator::Profile *)((Ogre::TerrainMaterialGenerator const *)arg1)->getActiveProfile();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainMaterialGenerator__Profile, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator__markChanged(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","_markChanged", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  (arg1)->_markChanged();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_getChangeCount(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned long long 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator const *","getChangeCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  result = (unsigned long long)((Ogre::TerrainMaterialGenerator const *)arg1)->getChangeCount();
  vresult = SWIG_From_unsigned_SS_long_SS_long(static_cast< unsigned long long >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_getLayerDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainLayerDeclaration *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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator const *","getLayerDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  result = (Ogre::TerrainLayerDeclaration *) &((Ogre::TerrainMaterialGenerator const *)arg1)->getLayerDeclaration();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainLayerDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_canGenerateUsingDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::TerrainLayerDeclaration *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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","canGenerateUsingDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TerrainLayerDeclaration,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration const &","canGenerateUsingDeclaration", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TerrainLayerDeclaration const &","canGenerateUsingDeclaration", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp2);
  result = (bool)(arg1)->canGenerateUsingDeclaration((Ogre::TerrainLayerDeclaration const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_isVertexCompressionSupported(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator const *","isVertexCompressionSupported", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  result = (bool)((Ogre::TerrainMaterialGenerator const *)arg1)->isVertexCompressionSupported();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_requestOptions(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::Terrain *arg2 = (Ogre::Terrain *) 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","requestOptions", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Terrain *","requestOptions", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Terrain * >(argp2);
  (arg1)->requestOptions(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_generate(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::Terrain *arg2 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::MaterialPtr 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","generate", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Terrain const *","generate", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Terrain * >(argp2);
  result = (arg1)->generate((Ogre::Terrain const *)arg2);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_generateForCompositeMap(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::Terrain *arg2 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::MaterialPtr 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","generateForCompositeMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Terrain const *","generateForCompositeMap", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Terrain * >(argp2);
  result = (arg1)->generateForCompositeMap((Ogre::Terrain const *)arg2);
  vresult = SWIG_NewPointerObj((new Ogre::MaterialPtr(static_cast< const Ogre::MaterialPtr& >(result))), SWIGTYPE_p_Ogre__MaterialPtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_getMaxLayers(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::Terrain *arg2 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  Ogre::uint8 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator const *","getMaxLayers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMaxLayers", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Terrain * >(argp2);
  result = (Ogre::uint8)((Ogre::TerrainMaterialGenerator const *)arg1)->getMaxLayers((Ogre::Terrain const *)arg2);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_updateCompositeMap(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::Terrain *arg2 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","updateCompositeMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Terrain const *","updateCompositeMap", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Terrain * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Rect const &","updateCompositeMap", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","updateCompositeMap", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Rect * >(argp3);
  (arg1)->updateCompositeMap((Ogre::Terrain const *)arg2,(Ogre::Rect const &)*arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_updateParams(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  Ogre::Terrain *arg3 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","updateParams", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","updateParams", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","updateParams", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Terrain const *","updateParams", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Terrain * >(argp3);
  (arg1)->updateParams((Ogre::MaterialPtr const &)*arg2,(Ogre::Terrain const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_updateParamsForCompositeMap(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  Ogre::MaterialPtr *arg2 = 0 ;
  Ogre::Terrain *arg3 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","updateParamsForCompositeMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","updateParamsForCompositeMap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","updateParamsForCompositeMap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::MaterialPtr * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Terrain const *","updateParamsForCompositeMap", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Terrain * >(argp3);
  (arg1)->updateParamsForCompositeMap((Ogre::MaterialPtr const &)*arg2,(Ogre::Terrain const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_setDebugLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","setDebugLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(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","setDebugLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned int >(val2);
  (arg1)->setDebugLevel(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator_getDebugLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned 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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator const *","getDebugLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  result = (unsigned int)((Ogre::TerrainMaterialGenerator const *)arg1)->getDebugLevel();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator__renderCompositeMap(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  size_t arg2 ;
  Ogre::Rect *arg3 = 0 ;
  Ogre::MaterialPtr *arg4 = 0 ;
  Ogre::TexturePtr *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  void *argp5 ;
  int res5 = 0 ;
  
  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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","_renderCompositeMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","_renderCompositeMap", 2, argv[0] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Rect const &","_renderCompositeMap", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","_renderCompositeMap", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Rect * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__MaterialPtr,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::MaterialPtr const &","_renderCompositeMap", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::MaterialPtr const &","_renderCompositeMap", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::MaterialPtr * >(argp4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__TexturePtr,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::TexturePtr const &","_renderCompositeMap", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TexturePtr const &","_renderCompositeMap", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::TexturePtr * >(argp5);
  (arg1)->_renderCompositeMap(arg2,(Ogre::Rect const &)*arg3,(Ogre::MaterialPtr const &)*arg4,(Ogre::TexturePtr const &)*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainMaterialGenerator__getCompositeMapRTT(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainMaterialGenerator *arg1 = (Ogre::TerrainMaterialGenerator *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Texture *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_Ogre__TerrainMaterialGenerator, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGenerator *","_getCompositeMapRTT", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainMaterialGenerator * >(argp1);
  result = (Ogre::Texture *)(arg1)->_getCompositeMapRTT();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Texture, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassTerrainMaterialGeneratorA;

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

SWIGINTERN VALUE
_wrap_new_TerrainMaterialGeneratorA(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TerrainMaterialGeneratorA";
  Ogre::TerrainMaterialGeneratorA *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainMaterialGeneratorA *)new Ogre::TerrainMaterialGeneratorA();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainMaterialGeneratorA(Ogre::TerrainMaterialGeneratorA *arg1) {
    delete arg1;
}

swig_class SwigClassTerrainPagedWorldSection;

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

SWIGINTERN VALUE
_wrap_new_TerrainPagedWorldSection(int argc, VALUE *argv, VALUE self) {
  Ogre::String *arg1 = 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::SceneManager *arg3 = (Ogre::SceneManager *) 0 ;
  int res1 = SWIG_OLDOBJ ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainPagedWorldSection";
  Ogre::TerrainPagedWorldSection *result = 0 ;
  
  if ((argc < 3) || (argc > 3)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",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 &","Ogre::TerrainPagedWorldSection", 1, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","Ogre::TerrainPagedWorldSection", 1, argv[0])); 
    }
    arg1 = ptr;
  }
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","Ogre::TerrainPagedWorldSection", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::TerrainPagedWorldSection", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::SceneManager * >(argp3);
  result = (Ogre::TerrainPagedWorldSection *)new Ogre::TerrainPagedWorldSection((Ogre::String const &)*arg1,arg2,arg3);
  DATA_PTR(self) = result;
  if (SWIG_IsNewObj(res1)) delete arg1;
  return self;
fail:
  if (SWIG_IsNewObj(res1)) delete arg1;
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainPagedWorldSection(Ogre::TerrainPagedWorldSection *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_init(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::TerrainGroup *arg2 = (Ogre::TerrainGroup *) 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","init", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","init", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainGroup * >(argp2);
  (arg1)->init(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getTerrainGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainGroup *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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","getTerrainGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::TerrainGroup *)(arg1)->getTerrainGroup();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_setLoadRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","setLoadRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setLoadRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setLoadRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getLoadRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection const *","getLoadRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::Real)((Ogre::TerrainPagedWorldSection const *)arg1)->getLoadRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_setHoldRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","setHoldRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setHoldRadius", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setHoldRadius(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getHoldRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","getHoldRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::Real)(arg1)->getHoldRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_setPageRange(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::int32 arg2 ;
  Ogre::int32 arg3 ;
  Ogre::int32 arg4 ;
  Ogre::int32 arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","setPageRange", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setPageRange", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::int32","setPageRange", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::int32 >(val3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::int32","setPageRange", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::int32 >(val4);
  ecode5 = SWIG_AsVal_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::int32","setPageRange", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::int32 >(val5);
  (arg1)->setPageRange(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_setPageRangeMinX(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","setPageRangeMinX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setPageRangeMinX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setPageRangeMinX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_setPageRangeMinY(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","setPageRangeMinY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setPageRangeMinY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setPageRangeMinY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_setPageRangeMaxX(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","setPageRangeMaxX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setPageRangeMaxX", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setPageRangeMaxX(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_setPageRangeMaxY(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::int32 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","setPageRangeMaxY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::int32","setPageRangeMaxY", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::int32 >(val2);
  (arg1)->setPageRangeMaxY(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getPageRangeMinX(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection const *","getPageRangeMinX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMinX();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getPageRangeMinY(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection const *","getPageRangeMinY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMinY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getPageRangeMaxX(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection const *","getPageRangeMaxX", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMaxX();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getPageRangeMaxY(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::int32 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection const *","getPageRangeMaxY", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::int32)((Ogre::TerrainPagedWorldSection const *)arg1)->getPageRangeMaxY();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getGridStrategy(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Grid2DPageStrategy *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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection const *","getGridStrategy", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::Grid2DPageStrategy *)((Ogre::TerrainPagedWorldSection const *)arg1)->getGridStrategy();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Grid2DPageStrategy, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_getGridStrategyData(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Grid2DPageStrategyData *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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection const *","getGridStrategyData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  result = (Ogre::Grid2DPageStrategyData *)((Ogre::TerrainPagedWorldSection const *)arg1)->getGridStrategyData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Grid2DPageStrategyData, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_loadPage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::PageID arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","loadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","loadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","loadPage", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->loadPage(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_loadPage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::PageID 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","loadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","loadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  (arg1)->loadPage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainPagedWorldSection_loadPage(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_Ogre__TerrainPagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TerrainPagedWorldSection_loadPage__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TerrainPagedWorldSection_loadPage__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainPagedWorldSection.loadPage", 
    "    void TerrainPagedWorldSection.loadPage(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void TerrainPagedWorldSection.loadPage(Ogre::PageID pageID)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_unloadPage__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::PageID arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned int val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","unloadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","unloadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","unloadPage", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->unloadPage(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPagedWorldSection_unloadPage__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPagedWorldSection *arg1 = (Ogre::TerrainPagedWorldSection *) 0 ;
  Ogre::PageID 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_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPagedWorldSection *","unloadPage", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPagedWorldSection * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::PageID","unloadPage", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::PageID >(val2);
  (arg1)->unloadPage(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainPagedWorldSection_unloadPage(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_Ogre__TerrainPagedWorldSection, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_TerrainPagedWorldSection_unloadPage__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 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_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_TerrainPagedWorldSection_unloadPage__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "TerrainPagedWorldSection.unloadPage", 
    "    void TerrainPagedWorldSection.unloadPage(Ogre::PageID pageID, bool forceSynchronous)\n"
    "    void TerrainPagedWorldSection.unloadPage(Ogre::PageID pageID)\n");
  
  return Qnil;
}


swig_class SwigClassTerrainPaging;

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

SWIGINTERN VALUE
_wrap_new_TerrainPaging(int argc, VALUE *argv, VALUE self) {
  Ogre::PageManager *arg1 = (Ogre::PageManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainPaging";
  Ogre::TerrainPaging *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__PageManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::PageManager *","Ogre::TerrainPaging", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::PageManager * >(argp1);
  result = (Ogre::TerrainPaging *)new Ogre::TerrainPaging(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainPaging(Ogre::TerrainPaging *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TerrainPaging_createWorldSection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPaging *arg1 = (Ogre::TerrainPaging *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::TerrainGroup *arg3 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::int32 arg6 ;
  Ogre::int32 arg7 ;
  Ogre::int32 arg8 ;
  Ogre::int32 arg9 ;
  Ogre::String *arg10 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  int res10 = SWIG_OLDOBJ ;
  Ogre::TerrainPagedWorldSection *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 9) || (argc > 9)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 9)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TerrainPaging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPaging *","createWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPaging * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createWorldSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","createWorldSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","createWorldSection", 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","createWorldSection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::int32 >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::int32 >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::int32 >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::int32 >(val9);
  {
    std::string *ptr = (std::string *)0;
    res10 = SWIG_AsPtr_std_string(argv[8], &ptr);
    if (!SWIG_IsOK(res10)) {
      SWIG_exception_fail(SWIG_ArgError(res10), Ruby_Format_TypeError( "", "Ogre::String const &","createWorldSection", 10, argv[8] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","createWorldSection", 10, argv[8])); 
    }
    arg10 = ptr;
  }
  result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9,(Ogre::String const &)*arg10);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  if (SWIG_IsNewObj(res10)) delete arg10;
  return vresult;
fail:
  if (SWIG_IsNewObj(res10)) delete arg10;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_createWorldSection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPaging *arg1 = (Ogre::TerrainPaging *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::TerrainGroup *arg3 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::int32 arg6 ;
  Ogre::int32 arg7 ;
  Ogre::int32 arg8 ;
  Ogre::int32 arg9 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  int val9 ;
  int ecode9 = 0 ;
  Ogre::TerrainPagedWorldSection *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TerrainPaging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPaging *","createWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPaging * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createWorldSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","createWorldSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","createWorldSection", 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","createWorldSection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::int32 >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::int32 >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::int32 >(val8);
  ecode9 = SWIG_AsVal_int(argv[7], &val9);
  if (!SWIG_IsOK(ecode9)) {
    SWIG_exception_fail(SWIG_ArgError(ecode9), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 9, argv[7] ));
  } 
  arg9 = static_cast< Ogre::int32 >(val9);
  result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_createWorldSection__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPaging *arg1 = (Ogre::TerrainPaging *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::TerrainGroup *arg3 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::int32 arg6 ;
  Ogre::int32 arg7 ;
  Ogre::int32 arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  int val8 ;
  int ecode8 = 0 ;
  Ogre::TerrainPagedWorldSection *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 7) || (argc > 7)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 7)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TerrainPaging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPaging *","createWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPaging * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createWorldSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","createWorldSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","createWorldSection", 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","createWorldSection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::int32 >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::int32 >(val7);
  ecode8 = SWIG_AsVal_int(argv[6], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 8, argv[6] ));
  } 
  arg8 = static_cast< Ogre::int32 >(val8);
  result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_createWorldSection__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPaging *arg1 = (Ogre::TerrainPaging *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::TerrainGroup *arg3 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::int32 arg6 ;
  Ogre::int32 arg7 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  int val7 ;
  int ecode7 = 0 ;
  Ogre::TerrainPagedWorldSection *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 6) || (argc > 6)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 6)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TerrainPaging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPaging *","createWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPaging * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createWorldSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","createWorldSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","createWorldSection", 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","createWorldSection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::int32 >(val6);
  ecode7 = SWIG_AsVal_int(argv[5], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 7, argv[5] ));
  } 
  arg7 = static_cast< Ogre::int32 >(val7);
  result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6,arg7);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_createWorldSection__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPaging *arg1 = (Ogre::TerrainPaging *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::TerrainGroup *arg3 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::int32 arg6 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  int val6 ;
  int ecode6 = 0 ;
  Ogre::TerrainPagedWorldSection *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__TerrainPaging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPaging *","createWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPaging * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createWorldSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","createWorldSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","createWorldSection", 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","createWorldSection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  ecode6 = SWIG_AsVal_int(argv[4], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::int32","createWorldSection", 6, argv[4] ));
  } 
  arg6 = static_cast< Ogre::int32 >(val6);
  result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5,arg6);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainPaging_createWorldSection__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainPaging *arg1 = (Ogre::TerrainPaging *) 0 ;
  Ogre::PagedWorld *arg2 = (Ogre::PagedWorld *) 0 ;
  Ogre::TerrainGroup *arg3 = (Ogre::TerrainGroup *) 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  Ogre::TerrainPagedWorldSection *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_Ogre__TerrainPaging, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainPaging *","createWorldSection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainPaging * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__PagedWorld, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::PagedWorld *","createWorldSection", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::PagedWorld * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__TerrainGroup, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::TerrainGroup *","createWorldSection", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::TerrainGroup * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","createWorldSection", 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","createWorldSection", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  result = (Ogre::TerrainPagedWorldSection *)(arg1)->createWorldSection(arg2,arg3,arg4,arg5);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainPagedWorldSection, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainPaging_createWorldSection(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[11];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 11) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPaging, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
        _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_TerrainPaging_createWorldSection__SWIG_5(nargs, args, self);
            }
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPaging, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
        _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) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                return _wrap_TerrainPaging_createWorldSection__SWIG_4(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  if (argc == 7) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPaging, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
        _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) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  return _wrap_TerrainPaging_createWorldSection__SWIG_3(nargs, args, self);
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 8) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPaging, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
        _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) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    return _wrap_TerrainPaging_createWorldSection__SWIG_2(nargs, args, self);
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 9) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPaging, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
        _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) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      return _wrap_TerrainPaging_createWorldSection__SWIG_1(nargs, args, self);
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  if (argc == 10) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainPaging, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__PagedWorld, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__TerrainGroup, 0);
        _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) {
              {
                int res = SWIG_AsVal_int(argv[5], NULL);
                _v = SWIG_CheckState(res);
              }
              if (_v) {
                {
                  int res = SWIG_AsVal_int(argv[6], NULL);
                  _v = SWIG_CheckState(res);
                }
                if (_v) {
                  {
                    int res = SWIG_AsVal_int(argv[7], NULL);
                    _v = SWIG_CheckState(res);
                  }
                  if (_v) {
                    {
                      int res = SWIG_AsVal_int(argv[8], NULL);
                      _v = SWIG_CheckState(res);
                    }
                    if (_v) {
                      int res = SWIG_AsPtr_std_string(argv[9], (std::string**)(0));
                      _v = SWIG_CheckState(res);
                      if (_v) {
                        return _wrap_TerrainPaging_createWorldSection__SWIG_0(nargs, args, self);
                      }
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 11, "TerrainPaging.createWorldSection", 
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.createWorldSection(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius, Ogre::int32 minX, Ogre::int32 minY, Ogre::int32 maxX, Ogre::int32 maxY, Ogre::String const &sectionName)\n"
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.createWorldSection(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius, Ogre::int32 minX, Ogre::int32 minY, Ogre::int32 maxX, Ogre::int32 maxY)\n"
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.createWorldSection(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius, Ogre::int32 minX, Ogre::int32 minY, Ogre::int32 maxX)\n"
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.createWorldSection(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius, Ogre::int32 minX, Ogre::int32 minY)\n"
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.createWorldSection(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius, Ogre::int32 minX)\n"
    "    Ogre::TerrainPagedWorldSection * TerrainPaging.createWorldSection(Ogre::PagedWorld *world, Ogre::TerrainGroup *terrainGroup, Ogre::Real loadRadius, Ogre::Real holdRadius)\n");
  
  return Qnil;
}


swig_class SwigClassTerrainQuadTreeNode;

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

SWIGINTERN VALUE
_wrap_new_TerrainQuadTreeNode(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::TerrainQuadTreeNode *arg2 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::uint16 arg3 ;
  Ogre::uint16 arg4 ;
  Ogre::uint16 arg5 ;
  Ogre::uint16 arg6 ;
  Ogre::uint16 arg7 ;
  Ogre::uint16 arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  unsigned short val8 ;
  int ecode8 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::TerrainQuadTreeNode";
  Ogre::TerrainQuadTreeNode *result = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","Ogre::TerrainQuadTreeNode", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2,SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","Ogre::TerrainQuadTreeNode", 2, argv[1] )); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::TerrainQuadTreeNode", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::TerrainQuadTreeNode", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::TerrainQuadTreeNode", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::TerrainQuadTreeNode", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::uint16 >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::TerrainQuadTreeNode", 7, argv[6] ));
  } 
  arg7 = static_cast< Ogre::uint16 >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_short(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::TerrainQuadTreeNode", 8, argv[7] ));
  } 
  arg8 = static_cast< Ogre::uint16 >(val8);
  result = (Ogre::TerrainQuadTreeNode *)new Ogre::TerrainQuadTreeNode(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainQuadTreeNode(Ogre::TerrainQuadTreeNode *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getXOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getXOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getXOffset();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getYOffset(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getYOffset", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getYOffset();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_isLeaf(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","isLeaf", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (bool)((Ogre::TerrainQuadTreeNode const *)arg1)->isLeaf();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getBaseLod(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getBaseLod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getBaseLod();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getLodCount(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getLodCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::uint16)((Ogre::TerrainQuadTreeNode const *)arg1)->getLodCount();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getChild(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  unsigned short arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::TerrainQuadTreeNode *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getChild", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(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","getChild", 2, argv[0] ));
  } 
  arg2 = static_cast< unsigned short >(val2);
  result = (Ogre::TerrainQuadTreeNode *)((Ogre::TerrainQuadTreeNode const *)arg1)->getChild(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getParent(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainQuadTreeNode *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getParent", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::TerrainQuadTreeNode *)((Ogre::TerrainQuadTreeNode const *)arg1)->getParent();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getTerrain(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Terrain *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getTerrain", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::Terrain *)((Ogre::TerrainQuadTreeNode const *)arg1)->getTerrain();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  (arg1)->prepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->prepare(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_TerrainQuadTreeNode_prepare(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_Ogre__TerrainQuadTreeNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_TerrainQuadTreeNode_prepare__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_TerrainQuadTreeNode_prepare__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "TerrainQuadTreeNode.prepare", 
    "    void TerrainQuadTreeNode.prepare()\n"
    "    void TerrainQuadTreeNode.prepare(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_load(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  (arg1)->unprepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_save(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getLodLevel(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::TerrainQuadTreeNode::LodLevel *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","getLodLevel", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","getLodLevel", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  result = (Ogre::TerrainQuadTreeNode::LodLevel *)(arg1)->getLodLevel(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode__LodLevel, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_preDeltaCalculation(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::Rect *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","preDeltaCalculation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","preDeltaCalculation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","preDeltaCalculation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->preDeltaCalculation((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_notifyDelta(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::uint16 arg4 ;
  Ogre::Real arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","notifyDelta", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","notifyDelta", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","notifyDelta", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","notifyDelta", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  ecode5 = SWIG_AsVal_float(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::Real","notifyDelta", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  (arg1)->notifyDelta(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_postDeltaCalculation(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::Rect *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","postDeltaCalculation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","postDeltaCalculation", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","postDeltaCalculation", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->postDeltaCalculation((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_finaliseDeltaValues(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::Rect *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","finaliseDeltaValues", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","finaliseDeltaValues", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","finaliseDeltaValues", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->finaliseDeltaValues((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_assignVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  Ogre::uint16 arg4 ;
  Ogre::uint arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned int val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","assignVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","assignVertexData", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","assignVertexData", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","assignVertexData", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_int(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint","assignVertexData", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::uint >(val5);
  (arg1)->assignVertexData(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_useAncestorVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::TerrainQuadTreeNode *arg2 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::uint16 arg3 ;
  Ogre::uint16 arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","useAncestorVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","useAncestorVertexData", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","useAncestorVertexData", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","useAncestorVertexData", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  (arg1)->useAncestorVertexData(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_updateVertexData(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  bool arg2 ;
  bool arg3 ;
  Ogre::Rect *arg4 = 0 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","updateVertexData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","updateVertexData", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","updateVertexData", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Rect const &","updateVertexData", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","updateVertexData", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Rect * >(argp4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","updateVertexData", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->updateVertexData(arg2,arg3,(Ogre::Rect const &)*arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_mergeIntoBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::Vector3 *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","mergeIntoBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","mergeIntoBounds", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","mergeIntoBounds", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  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 &","mergeIntoBounds", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","mergeIntoBounds", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->mergeIntoBounds(arg2,arg3,(Ogre::Vector3 const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_resetBounds(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::Rect *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","resetBounds", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","resetBounds", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","resetBounds", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->resetBounds((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_rectIntersectsNode(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::Rect *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","rectIntersectsNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","rectIntersectsNode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","rectIntersectsNode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  result = (bool)(arg1)->rectIntersectsNode((Ogre::Rect const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_rectContainsNode(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::Rect *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","rectContainsNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","rectContainsNode", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","rectContainsNode", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  result = (bool)(arg1)->rectContainsNode((Ogre::Rect const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_pointIntersectsNode(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","pointIntersectsNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","pointIntersectsNode", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","pointIntersectsNode", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (bool)(arg1)->pointIntersectsNode(arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getAABB(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getAABB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::TerrainQuadTreeNode const *)arg1)->getAABB();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::Real)((Ogre::TerrainQuadTreeNode const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getLocalCentre(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getLocalCentre", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::TerrainQuadTreeNode const *)arg1)->getLocalCentre();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getMinHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getMinHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::Real)((Ogre::TerrainQuadTreeNode const *)arg1)->getMinHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getMaxHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getMaxHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::Real)((Ogre::TerrainQuadTreeNode const *)arg1)->getMaxHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_calculateCurrentLod(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  Ogre::Camera *arg2 = (Ogre::Camera *) 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  bool 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","calculateCurrentLod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Camera, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Camera const *","calculateCurrentLod", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Camera * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","calculateCurrentLod", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (bool)(arg1)->calculateCurrentLod((Ogre::Camera const *)arg2,arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getCurrentLod(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getCurrentLod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (int)((Ogre::TerrainQuadTreeNode const *)arg1)->getCurrentLod();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_isRenderedAtCurrentLod(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","isRenderedAtCurrentLod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (bool)((Ogre::TerrainQuadTreeNode const *)arg1)->isRenderedAtCurrentLod();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_isSelfOrChildRenderedAtCurrentLod(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","isSelfOrChildRenderedAtCurrentLod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (bool)((Ogre::TerrainQuadTreeNode const *)arg1)->isSelfOrChildRenderedAtCurrentLod();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_setCurrentLod(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  int arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","setCurrentLod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","setCurrentLod", 2, argv[0] ));
  } 
  arg2 = static_cast< int >(val2);
  (arg1)->setCurrentLod(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_getLodTransition(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode const *","getLodTransition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (float)((Ogre::TerrainQuadTreeNode const *)arg1)->getLodTransition();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_setLodTransition(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  float arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","setLodTransition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "float","setLodTransition", 2, argv[0] ));
  } 
  arg2 = static_cast< float >(val2);
  (arg1)->setLodTransition(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_POSITION_BUFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::TerrainQuadTreeNode::POSITION_BUFFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_POSITION_BUFFER_set(VALUE self, VALUE _val) {
  {
    unsigned short val;
    int res = SWIG_AsVal_unsigned_SS_short(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::TerrainQuadTreeNode::POSITION_BUFFER""' of type '""unsigned short""'");
    }
    Ogre::TerrainQuadTreeNode::POSITION_BUFFER = static_cast< unsigned short >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_DELTA_BUFFER_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::TerrainQuadTreeNode::DELTA_BUFFER));
  return _val;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode_DELTA_BUFFER_set(VALUE self, VALUE _val) {
  {
    unsigned short val;
    int res = SWIG_AsVal_unsigned_SS_short(_val, &val);
    if (!SWIG_IsOK(res)) {
      SWIG_exception_fail(SWIG_ArgError(res), "in variable '""Ogre::TerrainQuadTreeNode::DELTA_BUFFER""' of type '""unsigned short""'");
    }
    Ogre::TerrainQuadTreeNode::DELTA_BUFFER = static_cast< unsigned short >(val);
  }
  return _val;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainQuadTreeNode__getRenderable(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainQuadTreeNode *arg1 = (Ogre::TerrainQuadTreeNode *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Renderable *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_Ogre__TerrainQuadTreeNode, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainQuadTreeNode *","_getRenderable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainQuadTreeNode * >(argp1);
  result = (Ogre::Renderable *)(arg1)->_getRenderable();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Renderable, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassTerrain;

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

SWIGINTERN VALUE
_wrap_new_Terrain(int argc, VALUE *argv, VALUE self) {
  Ogre::SceneManager *arg1 = (Ogre::SceneManager *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  const char *classname SWIGUNUSED = "Ogre::Terrain";
  Ogre::Terrain *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__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::SceneManager *","Ogre::Terrain", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::SceneManager * >(argp1);
  result = (Ogre::Terrain *)new Ogre::Terrain(arg1);
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_Terrain(Ogre::Terrain *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_Terrain_TERRAIN_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Terrain::TERRAIN_CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAIN_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::TERRAIN_CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAIN_MAX_BATCH_SIZE_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::TERRAIN_MAX_BATCH_SIZE));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERDECLARATION_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Terrain::TERRAINLAYERDECLARATION_CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERDECLARATION_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::TERRAINLAYERDECLARATION_CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERSAMPLER_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Terrain::TERRAINLAYERSAMPLER_CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERSAMPLER_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::TERRAINLAYERSAMPLER_CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Terrain::TERRAINLAYERSAMPLERELEMENT_CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERINSTANCE_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Terrain::TERRAINLAYERINSTANCE_CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINLAYERINSTANCE_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::TERRAINLAYERINSTANCE_CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINDERIVEDDATA_CHUNK_ID_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(Ogre::Terrain::TERRAINDERIVEDDATA_CHUNK_ID));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_TERRAINDERIVEDDATA_CHUNK_VERSION_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::TERRAINDERIVEDDATA_CHUNK_VERSION));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_LOD_MORPH_CUSTOM_PARAM_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_size_t(static_cast< size_t >(Ogre::Terrain::LOD_MORPH_CUSTOM_PARAM));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_getSceneManager(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneManager *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getSceneManager", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::SceneManager *)((Ogre::Terrain const *)arg1)->getSceneManager();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setGpuBufferAllocator(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::GpuBufferAllocator *arg2 = (Ogre::Terrain::GpuBufferAllocator *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setGpuBufferAllocator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Terrain__GpuBufferAllocator, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Terrain::GpuBufferAllocator *","setGpuBufferAllocator", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Terrain::GpuBufferAllocator * >(argp2);
  (arg1)->setGpuBufferAllocator(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getGpuBufferAllocator(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Terrain::GpuBufferAllocator *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getGpuBufferAllocator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Terrain::GpuBufferAllocator *)(arg1)->getGpuBufferAllocator();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain__GpuBufferAllocator, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__getNumIndexesForBatchSize(int argc, VALUE *argv, VALUE self) {
  Ogre::uint16 arg1 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  size_t result;
  VALUE vresult = Qnil;
  
  if ((argc < 1) || (argc > 1)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_getNumIndexesForBatchSize", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint16 >(val1);
  result = Ogre::Terrain::_getNumIndexesForBatchSize(arg1);
  vresult = SWIG_From_size_t(static_cast< size_t >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__populateIndexBuffer(int argc, VALUE *argv, VALUE self) {
  Ogre::uint16 *arg1 = (Ogre::uint16 *) 0 ;
  Ogre::uint16 arg2 ;
  Ogre::uint16 arg3 ;
  size_t arg4 ;
  Ogre::uint16 arg5 ;
  Ogre::uint16 arg6 ;
  Ogre::uint16 arg7 ;
  Ogre::uint16 arg8 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 0 ;
  size_t val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  unsigned short val6 ;
  int ecode6 = 0 ;
  unsigned short val7 ;
  int ecode7 = 0 ;
  unsigned short val8 ;
  int ecode8 = 0 ;
  
  if ((argc < 8) || (argc > 8)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 8)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_unsigned_short, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::uint16 *","Ogre::Terrain::_populateIndexBuffer", 1, argv[0] )); 
  }
  arg1 = reinterpret_cast< Ogre::uint16 * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_populateIndexBuffer", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_populateIndexBuffer", 3, argv[2] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  ecode4 = SWIG_AsVal_size_t(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "size_t","Ogre::Terrain::_populateIndexBuffer", 4, argv[3] ));
  } 
  arg4 = static_cast< size_t >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_populateIndexBuffer", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  ecode6 = SWIG_AsVal_unsigned_SS_short(argv[5], &val6);
  if (!SWIG_IsOK(ecode6)) {
    SWIG_exception_fail(SWIG_ArgError(ecode6), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_populateIndexBuffer", 6, argv[5] ));
  } 
  arg6 = static_cast< Ogre::uint16 >(val6);
  ecode7 = SWIG_AsVal_unsigned_SS_short(argv[6], &val7);
  if (!SWIG_IsOK(ecode7)) {
    SWIG_exception_fail(SWIG_ArgError(ecode7), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_populateIndexBuffer", 7, argv[6] ));
  } 
  arg7 = static_cast< Ogre::uint16 >(val7);
  ecode8 = SWIG_AsVal_unsigned_SS_short(argv[7], &val8);
  if (!SWIG_IsOK(ecode8)) {
    SWIG_exception_fail(SWIG_ArgError(ecode8), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_populateIndexBuffer", 8, argv[7] ));
  } 
  arg8 = static_cast< Ogre::uint16 >(val8);
  Ogre::Terrain::_populateIndexBuffer(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__calcSkirtVertexIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::uint16 arg1 ;
  Ogre::uint16 arg2 ;
  bool arg3 ;
  Ogre::uint16 arg4 ;
  Ogre::uint16 arg5 ;
  unsigned short val1 ;
  int ecode1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  unsigned short val4 ;
  int ecode4 = 0 ;
  unsigned short val5 ;
  int ecode5 = 0 ;
  Ogre::uint16 result;
  VALUE vresult = Qnil;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  ecode1 = SWIG_AsVal_unsigned_SS_short(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_calcSkirtVertexIndex", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::uint16 >(val1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_calcSkirtVertexIndex", 2, argv[1] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  ecode3 = SWIG_AsVal_bool(argv[2], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","Ogre::Terrain::_calcSkirtVertexIndex", 3, argv[2] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_unsigned_SS_short(argv[3], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_calcSkirtVertexIndex", 4, argv[3] ));
  } 
  arg4 = static_cast< Ogre::uint16 >(val4);
  ecode5 = SWIG_AsVal_unsigned_SS_short(argv[4], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "Ogre::uint16","Ogre::Terrain::_calcSkirtVertexIndex", 5, argv[4] ));
  } 
  arg5 = static_cast< Ogre::uint16 >(val5);
  result = (Ogre::uint16)Ogre::Terrain::_calcSkirtVertexIndex(arg1,arg2,arg3,arg4,arg5);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convertPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::Space arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Terrain::Space arg4 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","convertPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::Space >(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 &","convertPosition", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertPosition", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Terrain::Space >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 &","convertPosition", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","convertPosition", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  ((Ogre::Terrain const *)arg1)->convertPosition(arg2,(Ogre::Vector3 const &)*arg3,arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convertPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::Space arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Terrain::Space arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::Vector3 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","convertPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertPosition", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::Space >(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 &","convertPosition", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertPosition", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Terrain::Space >(val4);
  result = ((Ogre::Terrain const *)arg1)->convertPosition(arg2,(Ogre::Vector3 const &)*arg3,arg4);
  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_Terrain_convertPosition(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Terrain_convertPosition__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_convertPosition__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.convertPosition", 
    "    Ogre::Vector3 Terrain.convertPosition(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inPos, Ogre::Terrain::Space outSpace, Ogre::Vector3 &outPos)\n"
    "    Ogre::Vector3 Terrain.convertPosition(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inPos, Ogre::Terrain::Space outSpace)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convertDirection__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::Space arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Terrain::Space arg4 ;
  Ogre::Vector3 *arg5 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","convertDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertDirection", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::Space >(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 &","convertDirection", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertDirection", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertDirection", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Terrain::Space >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5, SWIGTYPE_p_Ogre__Vector3,  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 &","convertDirection", 5, argv[3] )); 
  }
  if (!argp5) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 &","convertDirection", 5, argv[3])); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  ((Ogre::Terrain const *)arg1)->convertDirection(arg2,(Ogre::Vector3 const &)*arg3,arg4,*arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convertDirection__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::Space arg2 ;
  Ogre::Vector3 *arg3 = 0 ;
  Ogre::Terrain::Space arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  int val4 ;
  int ecode4 = 0 ;
  Ogre::Vector3 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","convertDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertDirection", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::Space >(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 &","convertDirection", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","convertDirection", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  ecode4 = SWIG_AsVal_int(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Terrain::Space","convertDirection", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Terrain::Space >(val4);
  result = ((Ogre::Terrain const *)arg1)->convertDirection(arg2,(Ogre::Vector3 const &)*arg3,arg4);
  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_Terrain_convertDirection(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Terrain_convertDirection__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(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) {
          {
            int res = SWIG_AsVal_int(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_convertDirection__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.convertDirection", 
    "    Ogre::Vector3 Terrain.convertDirection(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inDir, Ogre::Terrain::Space outSpace, Ogre::Vector3 &outDir)\n"
    "    Ogre::Vector3 Terrain.convertDirection(Ogre::Terrain::Space inSpace, Ogre::Vector3 const &inDir, Ogre::Terrain::Space outSpace)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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( "", "Ogre::String const &","setResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__getDerivedResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","_getDerivedResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->_getDerivedResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_save__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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( "", "Ogre::String const &","save", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","save", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->save((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_save__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","save", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","save", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","save", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->save(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_save(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Terrain_save__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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_Terrain_save__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.save", 
    "    void Terrain.save(Ogre::String const &filename)\n"
    "    void Terrain.save(Ogre::StreamSerialiser &stream)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_prepare__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::String *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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( "", "Ogre::String const &","prepare", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","prepare", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  result = (bool)(arg1)->prepare((Ogre::String const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  if (SWIG_IsNewObj(res2)) delete arg2;
  return vresult;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_prepare__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  result = (bool)(arg1)->prepare(*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_prepare__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  ImportData *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","prepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_ImportData,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "ImportData const &","prepare", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "ImportData const &","prepare", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< ImportData * >(argp2);
  result = (bool)(arg1)->prepare((ImportData const &)*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_prepare(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Terrain_prepare__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_ImportData, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Terrain_prepare__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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_Terrain_prepare__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.prepare", 
    "    bool Terrain.prepare(Ogre::String const &filename)\n"
    "    bool Terrain.prepare(Ogre::StreamSerialiser &stream)\n"
    "    bool Terrain.prepare(ImportData const &importData)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_load__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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( "", "Ogre::String const &","load", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","load", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->load((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_load__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::StreamSerialiser *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","load", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","load", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  (arg1)->load(*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_load__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","load", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->load();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_load(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_load__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__StreamSerialiser, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Terrain_load__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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_Terrain_load__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.load", 
    "    void Terrain.load(Ogre::String const &filename)\n"
    "    void Terrain.load(Ogre::StreamSerialiser &stream)\n"
    "    void Terrain.load()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_isLoaded(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","isLoaded", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (bool)((Ogre::Terrain const *)arg1)->isLoaded();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_isModified(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","isModified", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (bool)((Ogre::Terrain const *)arg1)->isModified();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_isHeightDataModified(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","isHeightDataModified", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (bool)((Ogre::Terrain const *)arg1)->isHeightDataModified();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_unload(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","unload", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->unload();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_unprepare(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","unprepare", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->unprepare();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getHeightData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getHeightData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (float *)((Ogre::Terrain const *)arg1)->getHeightData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getHeightData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  float *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getHeightData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getHeightData", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getHeightData", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (float *)((Ogre::Terrain const *)arg1)->getHeightData(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getHeightData(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_getHeightData__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_getHeightData__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.getHeightData", 
    "    float * Terrain.getHeightData()\n"
    "    float * Terrain.getHeightData(long x, long y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getHeightAtPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  float 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getHeightAtPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getHeightAtPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getHeightAtPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (float)((Ogre::Terrain const *)arg1)->getHeightAtPoint(arg2,arg3);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setHeightAtPoint(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  float arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setHeightAtPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","setHeightAtPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","setHeightAtPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","setHeightAtPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  (arg1)->setHeightAtPoint(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getHeightAtTerrainPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getHeightAtTerrainPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getHeightAtTerrainPosition", 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","getHeightAtTerrainPosition", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (float)(arg1)->getHeightAtTerrainPosition(arg2,arg3);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getHeightAtWorldPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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 ;
  float 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getHeightAtWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getHeightAtWorldPosition", 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","getHeightAtWorldPosition", 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","getHeightAtWorldPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (float)(arg1)->getHeightAtWorldPosition(arg2,arg3,arg4);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getHeightAtWorldPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getHeightAtWorldPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getHeightAtWorldPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getHeightAtWorldPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  result = (float)(arg1)->getHeightAtWorldPosition((Ogre::Vector3 const &)*arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getHeightAtWorldPosition(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_Ogre__Terrain, 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_Terrain_getHeightAtWorldPosition__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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_Terrain_getHeightAtWorldPosition__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Terrain.getHeightAtWorldPosition", 
    "    float Terrain.getHeightAtWorldPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z)\n"
    "    float Terrain.getHeightAtWorldPosition(Ogre::Vector3 const &pos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getDeltaData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getDeltaData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (float *)(arg1)->getDeltaData();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getDeltaData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  float *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getDeltaData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getDeltaData", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getDeltaData", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (float *)(arg1)->getDeltaData(arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_float, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getDeltaData(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_getDeltaData__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_getDeltaData__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.getDeltaData", 
    "    float const * Terrain.getDeltaData()\n"
    "    float const * Terrain.getDeltaData(long x, long y)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPoint__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getPoint", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->getPoint(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPointFromSelfOrNeighbour(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getPointFromSelfOrNeighbour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getPointFromSelfOrNeighbour", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getPointFromSelfOrNeighbour", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getPointFromSelfOrNeighbour", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->getPointFromSelfOrNeighbour(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPoint__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  float arg4 ;
  Ogre::Vector3 *arg5 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getPoint", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getPoint", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getPoint", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "float","getPoint", 4, argv[2] ));
  } 
  arg4 = static_cast< float >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getPoint", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getPoint(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getPoint(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 == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _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_Terrain_getPoint__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_getPoint__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.getPoint", 
    "    void Terrain.getPoint(long x, long y, Ogre::Vector3 *outpos)\n"
    "    void Terrain.getPoint(long x, long y, float height, Ogre::Vector3 *outpos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPointTransform(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Matrix4 *arg2 = (Ogre::Matrix4 *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getPointTransform", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__Matrix4, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Matrix4 *","getPointTransform", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::Matrix4 * >(argp2);
  ((Ogre::Terrain const *)arg1)->getPointTransform(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getTerrainVector", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getTerrainVector", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainVector", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->getTerrainVector((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainVectorAlign__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Terrain::Alignment arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainVectorAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getTerrainVectorAlign", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getTerrainVectorAlign", 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( "", "Ogre::Terrain::Alignment","getTerrainVectorAlign", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Terrain::Alignment >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainVectorAlign", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->getTerrainVectorAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Vector3 *arg5 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTerrainVector", 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","getTerrainVector", 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","getTerrainVector", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainVector", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getTerrainVector(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getTerrainVector(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_Ogre__Terrain, 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_Terrain_getTerrainVector__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_getTerrainVector__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.getTerrainVector", 
    "    void Terrain.getTerrainVector(Ogre::Vector3 const &inVec, Ogre::Vector3 *outVec)\n"
    "    void Terrain.getTerrainVector(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainVectorAlign__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Terrain::Alignment arg5 ;
  Ogre::Vector3 *arg6 = (Ogre::Vector3 *) 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainVectorAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTerrainVectorAlign", 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","getTerrainVectorAlign", 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","getTerrainVectorAlign", 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( "", "Ogre::Terrain::Alignment","getTerrainVectorAlign", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Terrain::Alignment >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainVectorAlign", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Vector3 * >(argp6);
  (arg1)->getTerrainVectorAlign(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getTerrainVectorAlign(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Terrain_getTerrainVectorAlign__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Terrain_getTerrainVectorAlign__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.getTerrainVectorAlign", 
    "    void Terrain.getTerrainVectorAlign(Ogre::Vector3 const &inVec, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n"
    "    void Terrain.getTerrainVectorAlign(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getVector", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getVector", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getVector", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->getVector((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getVectorAlign__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Terrain::Alignment arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getVectorAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getVectorAlign", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getVectorAlign", 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( "", "Ogre::Terrain::Alignment","getVectorAlign", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Terrain::Alignment >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getVectorAlign", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->getVectorAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Vector3 *arg5 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getVector", 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","getVector", 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","getVector", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getVector", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getVector(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getVector(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_Ogre__Terrain, 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_Terrain_getVector__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_getVector__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.getVector", 
    "    void Terrain.getVector(Ogre::Vector3 const &inVec, Ogre::Vector3 *outVec)\n"
    "    void Terrain.getVector(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getVectorAlign__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Terrain::Alignment arg5 ;
  Ogre::Vector3 *arg6 = (Ogre::Vector3 *) 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getVectorAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getVectorAlign", 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","getVectorAlign", 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","getVectorAlign", 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( "", "Ogre::Terrain::Alignment","getVectorAlign", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Terrain::Alignment >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getVectorAlign", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Vector3 * >(argp6);
  (arg1)->getVectorAlign(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getVectorAlign(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Terrain_getVectorAlign__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Terrain_getVectorAlign__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.getVectorAlign", 
    "    void Terrain.getVectorAlign(Ogre::Vector3 const &inVec, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n"
    "    void Terrain.getVectorAlign(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outVec)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getPosition", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->getPosition((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Vector3 *arg5 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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);
  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);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","getPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getPosition", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getPosition(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainPosition__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getTerrainPosition", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getTerrainPosition", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainPosition", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  (arg1)->getTerrainPosition((Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainPosition__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Vector3 *arg5 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTerrainPosition", 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","getTerrainPosition", 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","getTerrainPosition", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainPosition", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::Vector3 * >(argp5);
  (arg1)->getTerrainPosition(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getTerrainPosition(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_Ogre__Terrain, 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_Terrain_getTerrainPosition__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_getTerrainPosition__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.getTerrainPosition", 
    "    void Terrain.getTerrainPosition(Ogre::Vector3 const &WSpos, Ogre::Vector3 *outTSpos)\n"
    "    void Terrain.getTerrainPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outTSpos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPositionAlign__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Terrain::Alignment arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getPositionAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getPositionAlign", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getPositionAlign", 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( "", "Ogre::Terrain::Alignment","getPositionAlign", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Terrain::Alignment >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getPositionAlign", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->getPositionAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPositionAlign__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Terrain::Alignment arg5 ;
  Ogre::Vector3 *arg6 = (Ogre::Vector3 *) 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getPositionAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getPositionAlign", 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","getPositionAlign", 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","getPositionAlign", 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( "", "Ogre::Terrain::Alignment","getPositionAlign", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Terrain::Alignment >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getPositionAlign", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Vector3 * >(argp6);
  (arg1)->getPositionAlign(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getPositionAlign(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Terrain_getPositionAlign__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Terrain_getPositionAlign__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.getPositionAlign", 
    "    void Terrain.getPositionAlign(Ogre::Vector3 const &TSpos, Ogre::Terrain::Alignment align, Ogre::Vector3 *outWSpos)\n"
    "    void Terrain.getPositionAlign(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outWSpos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainPositionAlign__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Terrain::Alignment arg3 ;
  Ogre::Vector3 *arg4 = (Ogre::Vector3 *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainPositionAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","getTerrainPositionAlign", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","getTerrainPositionAlign", 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( "", "Ogre::Terrain::Alignment","getTerrainPositionAlign", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Terrain::Alignment >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainPositionAlign", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Vector3 * >(argp4);
  (arg1)->getTerrainPositionAlign((Ogre::Vector3 const &)*arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainPositionAlign__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::Real arg3 ;
  Ogre::Real arg4 ;
  Ogre::Terrain::Alignment arg5 ;
  Ogre::Vector3 *arg6 = (Ogre::Vector3 *) 0 ;
  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 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getTerrainPositionAlign", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","getTerrainPositionAlign", 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","getTerrainPositionAlign", 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","getTerrainPositionAlign", 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( "", "Ogre::Terrain::Alignment","getTerrainPositionAlign", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Terrain::Alignment >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Vector3 *","getTerrainPositionAlign", 6, argv[4] )); 
  }
  arg6 = reinterpret_cast< Ogre::Vector3 * >(argp6);
  (arg1)->getTerrainPositionAlign(arg2,arg3,arg4,arg5,arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getTerrainPositionAlign(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Terrain_getTerrainPositionAlign__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Terrain_getTerrainPositionAlign__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.getTerrainPositionAlign", 
    "    void Terrain.getTerrainPositionAlign(Ogre::Vector3 const &WSpos, Ogre::Terrain::Alignment align, Ogre::Vector3 *outTSpos)\n"
    "    void Terrain.getTerrainPositionAlign(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Terrain::Alignment align, Ogre::Vector3 *outTSpos)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getAlignment(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::Terrain::Alignment 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getAlignment", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Terrain::Alignment)((Ogre::Terrain const *)arg1)->getAlignment();
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getMaxBatchSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMaxBatchSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getMaxBatchSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getMinBatchSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMinBatchSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getMinBatchSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getWorldSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setWorldSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setWorldSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerCount(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLayerCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getLayerCount();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainLayerDeclaration *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLayerDeclaration", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::TerrainLayerDeclaration *) &((Ogre::Terrain const *)arg1)->getLayerDeclaration();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainLayerDeclaration, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_addLayer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  Ogre::StringVector *arg3 = (Ogre::StringVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float val2 ;
  int ecode2 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","addLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::StringVector const *","addLayer", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::StringVector * >(argp3);
  (arg1)->addLayer(arg2,(Ogre::StringVector const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_addLayer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","addLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","addLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->addLayer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_addLayer__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","addLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->addLayer();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_addLayer__SWIG_3(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::Real arg3 ;
  Ogre::StringVector *arg4 = (Ogre::StringVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","addLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","addLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addLayer", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::StringVector const *","addLayer", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::StringVector * >(argp4);
  (arg1)->addLayer(arg2,arg3,(Ogre::StringVector const *)arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_addLayer__SWIG_4(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","addLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","addLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","addLayer", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->addLayer(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_addLayer__SWIG_5(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","addLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","addLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->addLayer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_addLayer(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_addLayer__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_addLayer__SWIG_5(nargs, args, self);
      }
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_addLayer__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(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_Terrain_addLayer__SWIG_4(nargs, args, self);
        }
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Terrain_addLayer__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Terrain_addLayer__SWIG_3(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Terrain.addLayer", 
    "    void Terrain.addLayer(Ogre::Real worldSize, Ogre::StringVector const *textureNames)\n"
    "    void Terrain.addLayer(Ogre::Real worldSize)\n"
    "    void Terrain.addLayer()\n"
    "    void Terrain.addLayer(Ogre::uint8 index, Ogre::Real worldSize, Ogre::StringVector const *textureNames)\n"
    "    void Terrain.addLayer(Ogre::uint8 index, Ogre::Real worldSize)\n"
    "    void Terrain.addLayer(Ogre::uint8 index)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_removeLayer(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","removeLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","removeLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->removeLayer(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_replaceLayer__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  bool arg3 ;
  Ogre::Real arg4 ;
  Ogre::StringVector *arg5 = (Ogre::StringVector *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  void *argp5 = 0 ;
  int res5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","replaceLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","replaceLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","replaceLayer", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","replaceLayer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  res5 = SWIG_ConvertPtr(argv[3], &argp5,SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0 |  0 );
  if (!SWIG_IsOK(res5)) {
    SWIG_exception_fail(SWIG_ArgError(res5), Ruby_Format_TypeError( "", "Ogre::StringVector const *","replaceLayer", 5, argv[3] )); 
  }
  arg5 = reinterpret_cast< Ogre::StringVector * >(argp5);
  (arg1)->replaceLayer(arg2,arg3,arg4,(Ogre::StringVector const *)arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_replaceLayer__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  bool arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","replaceLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","replaceLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","replaceLayer", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","replaceLayer", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  (arg1)->replaceLayer(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_replaceLayer__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","replaceLayer", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","replaceLayer", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","replaceLayer", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->replaceLayer(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_replaceLayer(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_replaceLayer__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(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_Terrain_replaceLayer__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          {
            int res = SWIG_AsVal_float(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__vectorT_Ogre__String_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_replaceLayer__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.replaceLayer", 
    "    void Terrain.replaceLayer(Ogre::uint8 index, bool keepBlends, Ogre::Real worldSize, Ogre::StringVector const *textureNames)\n"
    "    void Terrain.replaceLayer(Ogre::uint8 index, bool keepBlends, Ogre::Real worldSize)\n"
    "    void Terrain.replaceLayer(Ogre::uint8 index, bool keepBlends)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getMaxLayers(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMaxLayers", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getMaxLayers();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLayerWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getLayerWorldSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getLayerWorldSize(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setLayerWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  float val3 ;
  int ecode3 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setLayerWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setLayerWorldSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","setLayerWorldSize", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  (arg1)->setLayerWorldSize(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerUVMultiplier(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLayerUVMultiplier", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getLayerUVMultiplier", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getLayerUVMultiplier(arg2);
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::uint8 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  Ogre::String *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLayerTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getLayerTextureName", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","getLayerTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getLayerTextureName(arg2,arg3);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setLayerTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  Ogre::uint8 arg3 ;
  Ogre::String *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 0 ;
  int res4 = SWIG_OLDOBJ ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setLayerTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setLayerTextureName", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","setLayerTextureName", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  {
    std::string *ptr = (std::string *)0;
    res4 = SWIG_AsPtr_std_string(argv[2], &ptr);
    if (!SWIG_IsOK(res4)) {
      SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::String const &","setLayerTextureName", 4, argv[2] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setLayerTextureName", 4, argv[2])); 
    }
    arg4 = ptr;
  }
  (arg1)->setLayerTextureName(arg2,arg3,(Ogre::String const &)*arg4);
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res4)) delete arg4;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerBlendMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLayerBlendMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getLayerBlendMapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLightmapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLightmapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getLightmapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLightmap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TexturePtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getLightmap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::TexturePtr *) &((Ogre::Terrain const *)arg1)->getLightmap();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getCompositeMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getCompositeMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getCompositeMapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getCompositeMap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TexturePtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getCompositeMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::TexturePtr *) &((Ogre::Terrain const *)arg1)->getCompositeMap();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getPosition__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Vector3 *) &((Ogre::Terrain const *)arg1)->getPosition();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getPosition(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 == 1) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_getPosition__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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_Terrain_getPosition__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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) {
            void *vptr = 0;
            int res = SWIG_ConvertPtr(argv[4], &vptr, SWIGTYPE_p_Ogre__Vector3, 0);
            _v = SWIG_CheckState(res);
            if (_v) {
              return _wrap_Terrain_getPosition__SWIG_1(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.getPosition", 
    "    Ogre::Vector3 const & Terrain.getPosition(Ogre::Vector3 const &TSpos, Ogre::Vector3 *outWSpos)\n"
    "    Ogre::Vector3 const & Terrain.getPosition(Ogre::Real x, Ogre::Real y, Ogre::Real z, Ogre::Vector3 *outWSpos)\n"
    "    Ogre::Vector3 const & Terrain.getPosition()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setPosition(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setPosition", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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);
  (arg1)->setPosition((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__getRootSceneNode(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::SceneNode *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","_getRootSceneNode", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::SceneNode *)((Ogre::Terrain const *)arg1)->_getRootSceneNode();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__SceneNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_dirty(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","dirty", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->dirty();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_dirtyRect(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","dirtyRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","dirtyRect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","dirtyRect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->dirtyRect((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__dirtyCompositeMapRect(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","_dirtyCompositeMapRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","_dirtyCompositeMapRect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","_dirtyCompositeMapRect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->_dirtyCompositeMapRect((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_dirtyLightmapRect(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","dirtyLightmapRect", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","dirtyLightmapRect", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","dirtyLightmapRect", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  (arg1)->dirtyLightmapRect((Ogre::Rect const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_dirtyLightmap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","dirtyLightmap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->dirtyLightmap();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_update__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","update", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->update(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_update__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","update", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->update();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_update(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_update__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_update__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.update", 
    "    void Terrain.update(bool synchronous)\n"
    "    void Terrain.update()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_updateGeometry(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","updateGeometry", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->updateGeometry();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_DERIVED_DATA_DELTAS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(Ogre::Terrain::DERIVED_DATA_DELTAS));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_DERIVED_DATA_NORMALS_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(Ogre::Terrain::DERIVED_DATA_NORMALS));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_DERIVED_DATA_LIGHTMAP_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(Ogre::Terrain::DERIVED_DATA_LIGHTMAP));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_DERIVED_DATA_ALL_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(Ogre::Terrain::DERIVED_DATA_ALL));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_updateDerivedData__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  Ogre::uint8 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned char val3 ;
  int ecode3 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","updateDerivedData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","updateDerivedData", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_char(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint8","updateDerivedData", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint8 >(val3);
  (arg1)->updateDerivedData(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_updateDerivedData__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","updateDerivedData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","updateDerivedData", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->updateDerivedData(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_updateDerivedData__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","updateDerivedData", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->updateDerivedData();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_updateDerivedData(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_updateDerivedData__SWIG_2(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_updateDerivedData__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_char(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_updateDerivedData__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.updateDerivedData", 
    "    void Terrain.updateDerivedData(bool synchronous, Ogre::uint8 typeMask)\n"
    "    void Terrain.updateDerivedData(bool synchronous)\n"
    "    void Terrain.updateDerivedData()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_updateCompositeMap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","updateCompositeMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->updateCompositeMap();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_updateCompositeMapWithDelay__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","updateCompositeMapWithDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","updateCompositeMapWithDelay", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->updateCompositeMapWithDelay(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_updateCompositeMapWithDelay__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","updateCompositeMapWithDelay", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->updateCompositeMapWithDelay();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_updateCompositeMapWithDelay(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_updateCompositeMapWithDelay__SWIG_1(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_float(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_updateCompositeMapWithDelay__SWIG_0(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.updateCompositeMapWithDelay", 
    "    void Terrain.updateCompositeMapWithDelay(Ogre::Real delay)\n"
    "    void Terrain.updateCompositeMapWithDelay()\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getSkirtSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getSkirtSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getSkirtSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getNumLodLevels(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getNumLodLevels", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getNumLodLevels();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getNumLodLevelsPerLeaf(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getNumLodLevelsPerLeaf", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getNumLodLevelsPerLeaf();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_calculateHeightDeltas(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< Ogre::TRect< long > > 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","calculateHeightDeltas", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","calculateHeightDeltas", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","calculateHeightDeltas", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  result = (arg1)->calculateHeightDeltas((Ogre::Rect const &)*arg2);
  vresult = SWIG_NewPointerObj((new Ogre::Rect(static_cast< const Ogre::Rect& >(result))), SWIGTYPE_p_Ogre__TRectT_long_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_finaliseHeightDeltas(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","finaliseHeightDeltas", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","finaliseHeightDeltas", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","finaliseHeightDeltas", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","finaliseHeightDeltas", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->finaliseHeightDeltas((Ogre::Rect const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_calculateNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *arg2 = 0 ;
  Ogre::Rect *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::PixelBox *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","calculateNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","calculateNormals", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","calculateNormals", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Rect &","calculateNormals", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect &","calculateNormals", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Rect * >(argp3);
  result = (Ogre::PixelBox *)(arg1)->calculateNormals((Ogre::Rect const &)*arg2,*arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_finaliseNormals(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *arg2 = 0 ;
  Ogre::PixelBox *arg3 = (Ogre::PixelBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","finaliseNormals", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","finaliseNormals", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","finaliseNormals", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PixelBox *","finaliseNormals", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PixelBox * >(argp3);
  (arg1)->finaliseNormals((Ogre::Rect const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_calculateLightmap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *arg2 = 0 ;
  Ogre::Rect *arg3 = 0 ;
  Ogre::Rect *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  Ogre::PixelBox *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","calculateLightmap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","calculateLightmap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","calculateLightmap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Rect const &","calculateLightmap", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","calculateLightmap", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Rect * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Rect &","calculateLightmap", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect &","calculateLightmap", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Rect * >(argp4);
  result = (Ogre::PixelBox *)(arg1)->calculateLightmap((Ogre::Rect const &)*arg2,(Ogre::Rect const &)*arg3,*arg4);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_finaliseLightmap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Rect *arg2 = 0 ;
  Ogre::PixelBox *arg3 = (Ogre::PixelBox *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","finaliseLightmap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Rect const &","finaliseLightmap", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","finaliseLightmap", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Rect * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__PixelBox, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::PixelBox *","finaliseLightmap", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::PixelBox * >(argp3);
  (arg1)->finaliseLightmap((Ogre::Rect const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getResolutionAtLod(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short val2 ;
  int ecode2 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getResolutionAtLod", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","getResolutionAtLod", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  result = (Ogre::uint16)(arg1)->getResolutionAtLod(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_rayIntersects__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  bool arg3 ;
  Ogre::Real arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  SwigValueWrapper< std::pair< bool,Ogre::Vector3 > > 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","rayIntersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","rayIntersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","rayIntersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","rayIntersects", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","rayIntersects", 4, argv[2] ));
  } 
  arg4 = static_cast< Ogre::Real >(val4);
  result = (arg1)->rayIntersects((Ogre::Ray const &)*arg2,arg3,arg4);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Vector3 >(static_cast< const std::pair< bool,Ogre::Vector3 >& >(result))), SWIGTYPE_p_std__pairT_bool_Ogre__Vector3_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_rayIntersects__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  bool val3 ;
  int ecode3 = 0 ;
  SwigValueWrapper< std::pair< bool,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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","rayIntersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","rayIntersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","rayIntersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","rayIntersects", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  result = (arg1)->rayIntersects((Ogre::Ray const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Vector3 >(static_cast< const std::pair< bool,Ogre::Vector3 >& >(result))), SWIGTYPE_p_std__pairT_bool_Ogre__Vector3_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_rayIntersects__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  SwigValueWrapper< std::pair< bool,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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","rayIntersects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","rayIntersects", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","rayIntersects", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  result = (arg1)->rayIntersects((Ogre::Ray const &)*arg2);
  vresult = SWIG_NewPointerObj((new std::pair< bool,Ogre::Vector3 >(static_cast< const std::pair< bool,Ogre::Vector3 >& >(result))), SWIGTYPE_p_std__pairT_bool_Ogre__Vector3_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_rayIntersects(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Terrain_rayIntersects__SWIG_2(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_rayIntersects__SWIG_1(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_bool(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_Terrain_rayIntersects__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 5, "Terrain.rayIntersects", 
    "    std::pair< bool,Ogre::Vector3 > Terrain.rayIntersects(Ogre::Ray const &ray, bool cascadeToNeighbours, Ogre::Real distanceLimit)\n"
    "    std::pair< bool,Ogre::Vector3 > Terrain.rayIntersects(Ogre::Ray const &ray, bool cascadeToNeighbours)\n"
    "    std::pair< bool,Ogre::Vector3 > Terrain.rayIntersects(Ogre::Ray const &ray)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getAABB(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getAABB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::AxisAlignedBox *) &((Ogre::Terrain const *)arg1)->getAABB();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__AxisAlignedBox, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getWorldAABB(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::AxisAlignedBox 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getWorldAABB", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = ((Ogre::Terrain const *)arg1)->getWorldAABB();
  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_Terrain_getMinHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMinHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getMinHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getMaxHeight(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMaxHeight", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getMaxHeight();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getBoundingRadius(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getBoundingRadius", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::Real)((Ogre::Terrain const *)arg1)->getBoundingRadius();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__getMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","_getMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->_getMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getCompositeMapMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getCompositeMapMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->getCompositeMapMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__getCompositeMapMaterial(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::MaterialPtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","_getCompositeMapMaterial", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::MaterialPtr *) &((Ogre::Terrain const *)arg1)->_getCompositeMapMaterial();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__MaterialPtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getMaterialName(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getMaterialName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getMaterialName();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_preFindVisibleObjects(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 0 ;
  Ogre::SceneManager::IlluminationRenderStage arg3 ;
  Ogre::Viewport *arg4 = (Ogre::Viewport *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  int val3 ;
  int ecode3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","preFindVisibleObjects", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","preFindVisibleObjects", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  ecode3 = SWIG_AsVal_int(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::SceneManager::IlluminationRenderStage","preFindVisibleObjects", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::SceneManager::IlluminationRenderStage >(val3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4,SWIGTYPE_p_Ogre__Viewport, 0 |  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Viewport *","preFindVisibleObjects", 4, argv[2] )); 
  }
  arg4 = reinterpret_cast< Ogre::Viewport * >(argp4);
  (arg1)->preFindVisibleObjects(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_sceneManagerDestroyed(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::SceneManager *arg2 = (Ogre::SceneManager *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","sceneManagerDestroyed", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__SceneManager, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::SceneManager *","sceneManagerDestroyed", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::SceneManager * >(argp2);
  (arg1)->sceneManagerDestroyed(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getRenderQueueGroup();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint32)((Ogre::Terrain const *)arg1)->getVisibilityFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint32 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setVisibilityFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setVisibilityFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint32)((Ogre::Terrain const *)arg1)->getQueryFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint32 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_addQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint32 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","addQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","addQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->addQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_removeQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint32 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","removeQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","removeQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->removeQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerBlendMap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Ogre::TerrainLayerBlendMap *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getLayerBlendMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getLayerBlendMap", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::TerrainLayerBlendMap *)(arg1)->getLayerBlendMap(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainLayerBlendMap, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getBlendTextureIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Ogre::uint8 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getBlendTextureIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getBlendTextureIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getBlendTextureIndex(arg2);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getBlendTextureCount__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getBlendTextureCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getBlendTextureCount();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getBlendTextureCount__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Ogre::uint8 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getBlendTextureCount", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getBlendTextureCount", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::uint8)((Ogre::Terrain const *)arg1)->getBlendTextureCount(arg2);
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getBlendTextureCount(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      return _wrap_Terrain_getBlendTextureCount__SWIG_0(nargs, args, self);
    }
  }
  if (argc == 2) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_unsigned_SS_char(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_getBlendTextureCount__SWIG_1(nargs, args, self);
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 3, "Terrain.getBlendTextureCount", 
    "    Ogre::uint8 Terrain.getBlendTextureCount()\n"
    "    Ogre::uint8 Terrain.getBlendTextureCount(Ogre::uint8 numLayers)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getBlendTextureName(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Ogre::String *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getBlendTextureName", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getBlendTextureName", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::String *) &((Ogre::Terrain const *)arg1)->getBlendTextureName(arg2);
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setGlobalColourMapEnabled__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  Ogre::uint16 arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  unsigned short val3 ;
  int ecode3 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setGlobalColourMapEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setGlobalColourMapEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_unsigned_SS_short(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::uint16","setGlobalColourMapEnabled", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::uint16 >(val3);
  (arg1)->setGlobalColourMapEnabled(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setGlobalColourMapEnabled__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setGlobalColourMapEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setGlobalColourMapEnabled", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setGlobalColourMapEnabled(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_setGlobalColourMapEnabled(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_setGlobalColourMapEnabled__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_unsigned_SS_short(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_setGlobalColourMapEnabled__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.setGlobalColourMapEnabled", 
    "    void Terrain.setGlobalColourMapEnabled(bool enabled, Ogre::uint16 size)\n"
    "    void Terrain.setGlobalColourMapEnabled(bool enabled)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getGlobalColourMapEnabled(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getGlobalColourMapEnabled", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (bool)((Ogre::Terrain const *)arg1)->getGlobalColourMapEnabled();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getGlobalColourMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getGlobalColourMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::uint16)((Ogre::Terrain const *)arg1)->getGlobalColourMapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getGlobalColourMap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TexturePtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getGlobalColourMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::TexturePtr *) &((Ogre::Terrain const *)arg1)->getGlobalColourMap();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_widenRectByVector__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Rect *arg3 = 0 ;
  Ogre::Rect *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 = 0 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","widenRectByVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","widenRectByVector", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","widenRectByVector", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Rect const &","widenRectByVector", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","widenRectByVector", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Rect * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Rect &","widenRectByVector", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect &","widenRectByVector", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Rect * >(argp4);
  (arg1)->widenRectByVector((Ogre::Vector3 const &)*arg2,(Ogre::Rect const &)*arg3,*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_widenRectByVector__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Rect *arg3 = 0 ;
  Ogre::Real arg4 ;
  Ogre::Real arg5 ;
  Ogre::Rect *arg6 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  float val4 ;
  int ecode4 = 0 ;
  float val5 ;
  int ecode5 = 0 ;
  void *argp6 = 0 ;
  int res6 = 0 ;
  
  if ((argc < 5) || (argc > 5)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 5)",argc); SWIG_fail;
  }
  res1 = SWIG_ConvertPtr(self, &argp1,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","widenRectByVector", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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 &","widenRectByVector", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","widenRectByVector", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Rect const &","widenRectByVector", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","widenRectByVector", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Rect * >(argp3);
  ecode4 = SWIG_AsVal_float(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "Ogre::Real","widenRectByVector", 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","widenRectByVector", 5, argv[3] ));
  } 
  arg5 = static_cast< Ogre::Real >(val5);
  res6 = SWIG_ConvertPtr(argv[4], &argp6, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res6)) {
    SWIG_exception_fail(SWIG_ArgError(res6), Ruby_Format_TypeError( "", "Ogre::Rect &","widenRectByVector", 6, argv[4] )); 
  }
  if (!argp6) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect &","widenRectByVector", 6, argv[4])); 
  }
  arg6 = reinterpret_cast< Ogre::Rect * >(argp6);
  (arg1)->widenRectByVector((Ogre::Vector3 const &)*arg2,(Ogre::Rect const &)*arg3,arg4,arg5,*arg6);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_widenRectByVector(int nargs, VALUE *args, VALUE self) {
  int argc;
  VALUE argv[7];
  int ii;
  
  argc = nargs + 1;
  argv[0] = self;
  if (argc > 7) SWIG_fail;
  for (ii = 1; (ii < argc); ++ii) {
    argv[ii] = args[ii-1];
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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__TRectT_long_t, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          void *vptr = 0;
          int res = SWIG_ConvertPtr(argv[3], &vptr, SWIGTYPE_p_Ogre__TRectT_long_t, 0);
          _v = SWIG_CheckState(res);
          if (_v) {
            return _wrap_Terrain_widenRectByVector__SWIG_0(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 6) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 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__TRectT_long_t, 0);
        _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) {
              void *vptr = 0;
              int res = SWIG_ConvertPtr(argv[5], &vptr, SWIGTYPE_p_Ogre__TRectT_long_t, 0);
              _v = SWIG_CheckState(res);
              if (_v) {
                return _wrap_Terrain_widenRectByVector__SWIG_1(nargs, args, self);
              }
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 7, "Terrain.widenRectByVector", 
    "    void Terrain.widenRectByVector(Ogre::Vector3 const &vec, Ogre::Rect const &inRect, Ogre::Rect &outRect)\n"
    "    void Terrain.widenRectByVector(Ogre::Vector3 const &vec, Ogre::Rect const &inRect, Ogre::Real minHeight, Ogre::Real maxHeight, Ogre::Rect &outRect)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_freeTemporaryResources(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","freeTemporaryResources", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->freeTemporaryResources();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerBlendTexture(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  Ogre::TexturePtr *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getLayerBlendTexture", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getLayerBlendTexture", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (Ogre::TexturePtr *) &(arg1)->getLayerBlendTexture(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TexturePtr, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLayerBlendTextureIndex(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char val2 ;
  int ecode2 = 0 ;
  SwigValueWrapper< std::pair< unsigned char,unsigned char > > 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getLayerBlendTextureIndex", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","getLayerBlendTextureIndex", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  result = (arg1)->getLayerBlendTextureIndex(arg2);
  vresult = SWIG_NewPointerObj((new std::pair< Ogre::uint8,Ogre::uint8 >(static_cast< const std::pair< Ogre::uint8,Ogre::uint8 >& >(result))), SWIGTYPE_p_std__pairT_unsigned_char_unsigned_char_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__setMorphRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","_setMorphRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setMorphRequired", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setMorphRequired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__getMorphRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","_getMorphRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (bool)((Ogre::Terrain const *)arg1)->_getMorphRequired();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__setNormalMapRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","_setNormalMapRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setNormalMapRequired", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setNormalMapRequired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__setLightMapRequired__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  bool arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool val2 ;
  int ecode2 = 0 ;
  bool val3 ;
  int ecode3 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","_setLightMapRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setLightMapRequired", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  ecode3 = SWIG_AsVal_bool(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "bool","_setLightMapRequired", 3, argv[1] ));
  } 
  arg3 = static_cast< bool >(val3);
  (arg1)->_setLightMapRequired(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__setLightMapRequired__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","_setLightMapRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setLightMapRequired", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setLightMapRequired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain__setLightMapRequired(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain__setLightMapRequired__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_bool(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_bool(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain__setLightMapRequired__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain._setLightMapRequired", 
    "    void Terrain._setLightMapRequired(bool lightMap, bool shadowsOnly)\n"
    "    void Terrain._setLightMapRequired(bool lightMap)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__setCompositeMapRequired(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","_setCompositeMapRequired", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","_setCompositeMapRequired", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->_setCompositeMapRequired(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__getUseVertexCompression(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","_getUseVertexCompression", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (bool)((Ogre::Terrain const *)arg1)->_getUseVertexCompression();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_canHandleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","canHandleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","canHandleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_handleRequest(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::WorkQueue::Request *arg2 = (Ogre::WorkQueue::Request *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  Ogre::WorkQueue::Response *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","handleRequest", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Request, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Request const *","handleRequest", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Request * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleRequest", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (Ogre::WorkQueue::Response *)(arg1)->handleRequest((Ogre::WorkQueue::Request const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_canHandleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","canHandleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","canHandleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","canHandleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  result = (bool)(arg1)->canHandleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_handleResponse(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::WorkQueue::Response *arg2 = (Ogre::WorkQueue::Response *) 0 ;
  Ogre::WorkQueue *arg3 = (Ogre::WorkQueue *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","handleResponse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2,SWIGTYPE_p_Ogre__WorkQueue__Response, 0 |  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::WorkQueue::Response const *","handleResponse", 2, argv[0] )); 
  }
  arg2 = reinterpret_cast< Ogre::WorkQueue::Response * >(argp2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__WorkQueue, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::WorkQueue const *","handleResponse", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::WorkQueue * >(argp3);
  (arg1)->handleResponse((Ogre::WorkQueue::Response const *)arg2,(Ogre::WorkQueue const *)arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_WORKQUEUE_DERIVED_DATA_REQUEST_get(VALUE self) {
  VALUE _val;
  
  _val = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(Ogre::Terrain::WORKQUEUE_DERIVED_DATA_REQUEST));
  return _val;
}


SWIGINTERN VALUE
_wrap_Terrain_getLODLevelWhenVertexEliminated__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  long arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  long val3 ;
  int ecode3 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getLODLevelWhenVertexEliminated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getLODLevelWhenVertexEliminated", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  ecode3 = SWIG_AsVal_long(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "long","getLODLevelWhenVertexEliminated", 3, argv[1] ));
  } 
  arg3 = static_cast< long >(val3);
  result = (Ogre::uint16)(arg1)->getLODLevelWhenVertexEliminated(arg2,arg3);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getLODLevelWhenVertexEliminated__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  long arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  Ogre::uint16 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getLODLevelWhenVertexEliminated", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_long(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","getLODLevelWhenVertexEliminated", 2, argv[0] ));
  } 
  arg2 = static_cast< long >(val2);
  result = (Ogre::uint16)(arg1)->getLODLevelWhenVertexEliminated(arg2);
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_getLODLevelWhenVertexEliminated(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        return _wrap_Terrain_getLODLevelWhenVertexEliminated__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_long(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        {
          int res = SWIG_AsVal_long(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_getLODLevelWhenVertexEliminated__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.getLODLevelWhenVertexEliminated", 
    "    Ogre::uint16 Terrain.getLODLevelWhenVertexEliminated(long x, long y)\n"
    "    Ogre::uint16 Terrain.getLODLevelWhenVertexEliminated(long rowOrColulmn)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getQuadTree(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TerrainQuadTreeNode *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getQuadTree", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (Ogre::TerrainQuadTreeNode *)(arg1)->getQuadTree();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainQuadTreeNode, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getTerrainNormalMap(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::TexturePtr 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","getTerrainNormalMap", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = ((Ogre::Terrain const *)arg1)->getTerrainNormalMap();
  vresult = SWIG_NewPointerObj((new Ogre::TexturePtr(static_cast< const Ogre::TexturePtr& >(result))), SWIGTYPE_p_Ogre__TexturePtr, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getNeighbour(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::NeighbourIndex arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  Ogre::Terrain *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","getNeighbour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::NeighbourIndex","getNeighbour", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::NeighbourIndex >(val2);
  result = (Ogre::Terrain *)(arg1)->getNeighbour(arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setNeighbour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::NeighbourIndex arg2 ;
  Ogre::Terrain *arg3 = (Ogre::Terrain *) 0 ;
  bool arg4 ;
  bool arg5 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  bool val5 ;
  int ecode5 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setNeighbour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::NeighbourIndex","setNeighbour", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::NeighbourIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Terrain *","setNeighbour", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Terrain * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","setNeighbour", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  ecode5 = SWIG_AsVal_bool(argv[3], &val5);
  if (!SWIG_IsOK(ecode5)) {
    SWIG_exception_fail(SWIG_ArgError(ecode5), Ruby_Format_TypeError( "", "bool","setNeighbour", 5, argv[3] ));
  } 
  arg5 = static_cast< bool >(val5);
  (arg1)->setNeighbour(arg2,arg3,arg4,arg5);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setNeighbour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::NeighbourIndex arg2 ;
  Ogre::Terrain *arg3 = (Ogre::Terrain *) 0 ;
  bool arg4 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool val4 ;
  int ecode4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setNeighbour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::NeighbourIndex","setNeighbour", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::NeighbourIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Terrain *","setNeighbour", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Terrain * >(argp3);
  ecode4 = SWIG_AsVal_bool(argv[2], &val4);
  if (!SWIG_IsOK(ecode4)) {
    SWIG_exception_fail(SWIG_ArgError(ecode4), Ruby_Format_TypeError( "", "bool","setNeighbour", 4, argv[2] ));
  } 
  arg4 = static_cast< bool >(val4);
  (arg1)->setNeighbour(arg2,arg3,arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_setNeighbour__SWIG_2(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::NeighbourIndex arg2 ;
  Ogre::Terrain *arg3 = (Ogre::Terrain *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","setNeighbour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::NeighbourIndex","setNeighbour", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::NeighbourIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3,SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Terrain *","setNeighbour", 3, argv[1] )); 
  }
  arg3 = reinterpret_cast< Ogre::Terrain * >(argp3);
  (arg1)->setNeighbour(arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_setNeighbour(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          return _wrap_Terrain_setNeighbour__SWIG_2(nargs, args, self);
        }
      }
    }
  }
  if (argc == 4) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(argv[3], NULL);
            _v = SWIG_CheckState(res);
          }
          if (_v) {
            return _wrap_Terrain_setNeighbour__SWIG_1(nargs, args, self);
          }
        }
      }
    }
  }
  if (argc == 5) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      {
        int res = SWIG_AsVal_int(argv[1], NULL);
        _v = SWIG_CheckState(res);
      }
      if (_v) {
        void *vptr = 0;
        int res = SWIG_ConvertPtr(argv[2], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
        _v = SWIG_CheckState(res);
        if (_v) {
          {
            int res = SWIG_AsVal_bool(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_Terrain_setNeighbour__SWIG_0(nargs, args, self);
            }
          }
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 6, "Terrain.setNeighbour", 
    "    void Terrain.setNeighbour(Ogre::Terrain::NeighbourIndex index, Ogre::Terrain *neighbour, bool recalculate, bool notifyOther)\n"
    "    void Terrain.setNeighbour(Ogre::Terrain::NeighbourIndex index, Ogre::Terrain *neighbour, bool recalculate)\n"
    "    void Terrain.setNeighbour(Ogre::Terrain::NeighbourIndex index, Ogre::Terrain *neighbour)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getOppositeNeighbour(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain::NeighbourIndex arg1 ;
  int val1 ;
  int ecode1 = 0 ;
  Ogre::Terrain::NeighbourIndex result;
  VALUE vresult = Qnil;
  
  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( "", "Ogre::Terrain::NeighbourIndex","Ogre::Terrain::getOppositeNeighbour", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Terrain::NeighbourIndex >(val1);
  result = (Ogre::Terrain::NeighbourIndex)Ogre::Terrain::getOppositeNeighbour(arg1);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_getNeighbourIndex(int argc, VALUE *argv, VALUE self) {
  long arg1 ;
  long arg2 ;
  long val1 ;
  int ecode1 = 0 ;
  long val2 ;
  int ecode2 = 0 ;
  Ogre::Terrain::NeighbourIndex 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_long(argv[0], &val1);
  if (!SWIG_IsOK(ecode1)) {
    SWIG_exception_fail(SWIG_ArgError(ecode1), Ruby_Format_TypeError( "", "long","Ogre::Terrain::getNeighbourIndex", 1, argv[0] ));
  } 
  arg1 = static_cast< long >(val1);
  ecode2 = SWIG_AsVal_long(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "long","Ogre::Terrain::getNeighbourIndex", 2, argv[1] ));
  } 
  arg2 = static_cast< long >(val2);
  result = (Ogre::Terrain::NeighbourIndex)Ogre::Terrain::getNeighbourIndex(arg1,arg2);
  vresult = SWIG_From_int(static_cast< int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_notifyNeighbours(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","notifyNeighbours", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  (arg1)->notifyNeighbours();
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_neighbourModified(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Terrain::NeighbourIndex arg2 ;
  Ogre::Rect *arg3 = 0 ;
  Ogre::Rect *arg4 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int val2 ;
  int ecode2 = 0 ;
  void *argp3 ;
  int res3 = 0 ;
  void *argp4 ;
  int res4 = 0 ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","neighbourModified", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  ecode2 = SWIG_AsVal_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Terrain::NeighbourIndex","neighbourModified", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Terrain::NeighbourIndex >(val2);
  res3 = SWIG_ConvertPtr(argv[1], &argp3, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Rect const &","neighbourModified", 3, argv[1] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","neighbourModified", 3, argv[1])); 
  }
  arg3 = reinterpret_cast< Ogre::Rect * >(argp3);
  res4 = SWIG_ConvertPtr(argv[2], &argp4, SWIGTYPE_p_Ogre__TRectT_long_t,  0 );
  if (!SWIG_IsOK(res4)) {
    SWIG_exception_fail(SWIG_ArgError(res4), Ruby_Format_TypeError( "", "Ogre::Rect const &","neighbourModified", 4, argv[2] )); 
  }
  if (!argp4) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Rect const &","neighbourModified", 4, argv[2])); 
  }
  arg4 = reinterpret_cast< Ogre::Rect * >(argp4);
  (arg1)->neighbourModified(arg2,(Ogre::Rect const &)*arg3,(Ogre::Rect const &)*arg4);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_raySelectNeighbour__SWIG_0(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  Ogre::Real arg3 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  float val3 ;
  int ecode3 = 0 ;
  Ogre::Terrain *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","raySelectNeighbour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","raySelectNeighbour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","raySelectNeighbour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  ecode3 = SWIG_AsVal_float(argv[1], &val3);
  if (!SWIG_IsOK(ecode3)) {
    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "Ogre::Real","raySelectNeighbour", 3, argv[1] ));
  } 
  arg3 = static_cast< Ogre::Real >(val3);
  result = (Ogre::Terrain *)(arg1)->raySelectNeighbour((Ogre::Ray const &)*arg2,arg3);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_raySelectNeighbour__SWIG_1(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::Ray *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  Ogre::Terrain *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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","raySelectNeighbour", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__Ray,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::Ray const &","raySelectNeighbour", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Ray const &","raySelectNeighbour", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Ray * >(argp2);
  result = (Ogre::Terrain *)(arg1)->raySelectNeighbour((Ogre::Ray const &)*arg2);
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Terrain, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE _wrap_Terrain_raySelectNeighbour(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_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        return _wrap_Terrain_raySelectNeighbour__SWIG_1(nargs, args, self);
      }
    }
  }
  if (argc == 3) {
    int _v;
    void *vptr = 0;
    int res = SWIG_ConvertPtr(argv[0], &vptr, SWIGTYPE_p_Ogre__Terrain, 0);
    _v = SWIG_CheckState(res);
    if (_v) {
      void *vptr = 0;
      int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_Ogre__Ray, 0);
      _v = SWIG_CheckState(res);
      if (_v) {
        {
          int res = SWIG_AsVal_float(argv[2], NULL);
          _v = SWIG_CheckState(res);
        }
        if (_v) {
          return _wrap_Terrain_raySelectNeighbour__SWIG_0(nargs, args, self);
        }
      }
    }
  }
  
fail:
  Ruby_Format_OverloadedError( argc, 4, "Terrain.raySelectNeighbour", 
    "    Ogre::Terrain * Terrain.raySelectNeighbour(Ogre::Ray const &ray, Ogre::Real distanceLimit)\n"
    "    Ogre::Terrain * Terrain.raySelectNeighbour(Ogre::Ray const &ray)\n");
  
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain__dumpTextures(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 0 ;
  Ogre::String *arg2 = 0 ;
  Ogre::String *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  int res2 = SWIG_OLDOBJ ;
  int res3 = SWIG_OLDOBJ ;
  
  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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain *","_dumpTextures", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(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( "", "Ogre::String const &","_dumpTextures", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_dumpTextures", 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 &","_dumpTextures", 3, argv[1] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","_dumpTextures", 3, argv[1])); 
    }
    arg3 = ptr;
  }
  (arg1)->_dumpTextures((Ogre::String const &)*arg2,(Ogre::String const &)*arg3);
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  if (SWIG_IsNewObj(res3)) delete arg3;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_isDerivedDataUpdateInProgress(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain *arg1 = (Ogre::Terrain *) 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_Ogre__Terrain, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain const *","isDerivedDataUpdateInProgress", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain * >(argp1);
  result = (bool)((Ogre::Terrain const *)arg1)->isDerivedDataUpdateInProgress();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convertWorldToTerrainAxes(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain::Alignment arg1 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = (Ogre::Vector3 *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  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( "", "Ogre::Terrain::Alignment","Ogre::Terrain::convertWorldToTerrainAxes", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Terrain::Alignment >(val1);
  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 &","Ogre::Terrain::convertWorldToTerrainAxes", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Terrain::convertWorldToTerrainAxes", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 *","Ogre::Terrain::convertWorldToTerrainAxes", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  Ogre::Terrain::convertWorldToTerrainAxes(arg1,(Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_convertTerrainToWorldAxes(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain::Alignment arg1 ;
  Ogre::Vector3 *arg2 = 0 ;
  Ogre::Vector3 *arg3 = (Ogre::Vector3 *) 0 ;
  int val1 ;
  int ecode1 = 0 ;
  void *argp2 ;
  int res2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  
  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( "", "Ogre::Terrain::Alignment","Ogre::Terrain::convertTerrainToWorldAxes", 1, argv[0] ));
  } 
  arg1 = static_cast< Ogre::Terrain::Alignment >(val1);
  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 &","Ogre::Terrain::convertTerrainToWorldAxes", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","Ogre::Terrain::convertTerrainToWorldAxes", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3,SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Vector3 *","Ogre::Terrain::convertTerrainToWorldAxes", 3, argv[2] )); 
  }
  arg3 = reinterpret_cast< Ogre::Vector3 * >(argp3);
  Ogre::Terrain::convertTerrainToWorldAxes(arg1,(Ogre::Vector3 const &)*arg2,arg3);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_writeLayerDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainLayerDeclaration *arg1 = 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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__TerrainLayerDeclaration,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration const &","Ogre::Terrain::writeLayerDeclaration", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TerrainLayerDeclaration const &","Ogre::Terrain::writeLayerDeclaration", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","Ogre::Terrain::writeLayerDeclaration", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","Ogre::Terrain::writeLayerDeclaration", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  Ogre::Terrain::writeLayerDeclaration((Ogre::TerrainLayerDeclaration const &)*arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_readLayerDeclaration(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = 0 ;
  Ogre::TerrainLayerDeclaration *arg2 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 0 ;
  bool 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__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","Ogre::Terrain::readLayerDeclaration", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","Ogre::Terrain::readLayerDeclaration", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__TerrainLayerDeclaration,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainLayerDeclaration &","Ogre::Terrain::readLayerDeclaration", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TerrainLayerDeclaration &","Ogre::Terrain::readLayerDeclaration", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::TerrainLayerDeclaration * >(argp2);
  result = (bool)Ogre::Terrain::readLayerDeclaration(*arg1,*arg2);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_writeLayerInstanceList(int argc, VALUE *argv, VALUE self) {
  Ogre::Terrain::LayerInstanceList *arg1 = 0 ;
  Ogre::StreamSerialiser *arg2 = 0 ;
  void *argp1 ;
  int res1 = 0 ;
  void *argp2 = 0 ;
  int res2 = 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__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::Terrain::LayerInstanceList const &","Ogre::Terrain::writeLayerInstanceList", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Terrain::LayerInstanceList const &","Ogre::Terrain::writeLayerInstanceList", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::Terrain::LayerInstanceList * >(argp1);
  res2 = SWIG_ConvertPtr(argv[1], &argp2, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","Ogre::Terrain::writeLayerInstanceList", 2, argv[1] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","Ogre::Terrain::writeLayerInstanceList", 2, argv[1])); 
  }
  arg2 = reinterpret_cast< Ogre::StreamSerialiser * >(argp2);
  Ogre::Terrain::writeLayerInstanceList((Ogre::vector< LayerInstance,Ogre::STLAllocator< LayerInstance,Ogre::GeneralAllocPolicy > >::type const &)*arg1,*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_Terrain_readLayerInstanceList(int argc, VALUE *argv, VALUE self) {
  Ogre::StreamSerialiser *arg1 = 0 ;
  size_t arg2 ;
  Ogre::Terrain::LayerInstanceList *arg3 = 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  size_t val2 ;
  int ecode2 = 0 ;
  void *argp3 = 0 ;
  int res3 = 0 ;
  bool 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(argv[0], &argp1, SWIGTYPE_p_Ogre__StreamSerialiser,  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::StreamSerialiser &","Ogre::Terrain::readLayerInstanceList", 1, argv[0] )); 
  }
  if (!argp1) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::StreamSerialiser &","Ogre::Terrain::readLayerInstanceList", 1, argv[0])); 
  }
  arg1 = reinterpret_cast< Ogre::StreamSerialiser * >(argp1);
  ecode2 = SWIG_AsVal_size_t(argv[1], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "size_t","Ogre::Terrain::readLayerInstanceList", 2, argv[1] ));
  } 
  arg2 = static_cast< size_t >(val2);
  res3 = SWIG_ConvertPtr(argv[2], &argp3, SWIGTYPE_p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type,  0 );
  if (!SWIG_IsOK(res3)) {
    SWIG_exception_fail(SWIG_ArgError(res3), Ruby_Format_TypeError( "", "Ogre::Terrain::LayerInstanceList &","Ogre::Terrain::readLayerInstanceList", 3, argv[2] )); 
  }
  if (!argp3) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Terrain::LayerInstanceList &","Ogre::Terrain::readLayerInstanceList", 3, argv[2])); 
  }
  arg3 = reinterpret_cast< Ogre::Terrain::LayerInstanceList * >(argp3);
  result = (bool)Ogre::Terrain::readLayerInstanceList(*arg1,arg2,*arg3);
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


swig_class SwigClassTerrainGlobalOptions;

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

SWIGINTERN VALUE
_wrap_new_TerrainGlobalOptions(int argc, VALUE *argv, VALUE self) {
  const char *classname SWIGUNUSED = "Ogre::TerrainGlobalOptions";
  Ogre::TerrainGlobalOptions *result = 0 ;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainGlobalOptions *)new Ogre::TerrainGlobalOptions();
  DATA_PTR(self) = result;
  return self;
fail:
  return Qnil;
}


SWIGINTERN void
free_Ogre_TerrainGlobalOptions(Ogre::TerrainGlobalOptions *arg1) {
    delete arg1;
}

SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getSkirtSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getSkirtSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::Real)(arg1)->getSkirtSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setSkirtSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setSkirtSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setSkirtSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setSkirtSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getLightMapDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getLightMapDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::Vector3 *) &(arg1)->getLightMapDirection();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__Vector3, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setLightMapDirection(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::Vector3 *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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setLightMapDirection", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(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 &","setLightMapDirection", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::Vector3 const &","setLightMapDirection", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::Vector3 * >(argp2);
  (arg1)->setLightMapDirection((Ogre::Vector3 const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getCompositeMapAmbient(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getCompositeMapAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::ColourValue *) &(arg1)->getCompositeMapAmbient();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setCompositeMapAmbient(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::ColourValue *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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setCompositeMapAmbient", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setCompositeMapAmbient", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setCompositeMapAmbient", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setCompositeMapAmbient((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getCompositeMapDiffuse(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::ColourValue *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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getCompositeMapDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::ColourValue *) &(arg1)->getCompositeMapDiffuse();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__ColourValue, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setCompositeMapDiffuse(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::ColourValue *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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setCompositeMapDiffuse", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__ColourValue,  0 );
  if (!SWIG_IsOK(res2)) {
    SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::ColourValue const &","setCompositeMapDiffuse", 2, argv[0] )); 
  }
  if (!argp2) {
    SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::ColourValue const &","setCompositeMapDiffuse", 2, argv[0])); 
  }
  arg2 = reinterpret_cast< Ogre::ColourValue * >(argp2);
  (arg1)->setCompositeMapDiffuse((Ogre::ColourValue const &)*arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getCompositeMapDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getCompositeMapDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::Real)(arg1)->getCompositeMapDistance();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setCompositeMapDistance(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setCompositeMapDistance", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setCompositeMapDistance", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setCompositeMapDistance(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getCastsDynamicShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getCastsDynamicShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (bool)(arg1)->getCastsDynamicShadows();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setCastsDynamicShadows(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setCastsDynamicShadows", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setCastsDynamicShadows", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setCastsDynamicShadows(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getMaxPixelError(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getMaxPixelError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::Real)(arg1)->getMaxPixelError();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setMaxPixelError(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setMaxPixelError", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setMaxPixelError", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setMaxPixelError(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint8 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::uint8)(arg1)->getRenderQueueGroup();
  vresult = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setRenderQueueGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint8 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned char 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setRenderQueueGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_char(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint8","setRenderQueueGroup", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint8 >(val2);
  (arg1)->setRenderQueueGroup(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::uint32)(arg1)->getVisibilityFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setVisibilityFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint32 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setVisibilityFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setVisibilityFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setVisibilityFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint32 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","setQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->setQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint32 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::uint32)(arg1)->getQueryFlags();
  vresult = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_addQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint32 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","addQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","addQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->addQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_removeQueryFlags(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint32 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","removeQueryFlags", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_int(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint32","removeQueryFlags", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint32 >(val2);
  (arg1)->removeQueryFlags(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getUseRayBoxDistanceCalculation(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getUseRayBoxDistanceCalculation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (bool)(arg1)->getUseRayBoxDistanceCalculation();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setUseRayBoxDistanceCalculation(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setUseRayBoxDistanceCalculation", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseRayBoxDistanceCalculation", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseRayBoxDistanceCalculation(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getDefaultMaterialGenerator(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::TerrainMaterialGenerator > > 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getDefaultMaterialGenerator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (arg1)->getDefaultMaterialGenerator();
  vresult = SWIG_NewPointerObj((new Ogre::TerrainMaterialGeneratorPtr(static_cast< const Ogre::TerrainMaterialGeneratorPtr& >(result))), SWIGTYPE_p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t, SWIG_POINTER_OWN |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setDefaultMaterialGenerator(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  SwigValueWrapper< Ogre::SharedPtr< Ogre::TerrainMaterialGenerator > > arg2 ;
  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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setDefaultMaterialGenerator", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  {
    res2 = SWIG_ConvertPtr(argv[0], &argp2, SWIGTYPE_p_Ogre__SharedPtrT_Ogre__TerrainMaterialGenerator_t,  0 );
    if (!SWIG_IsOK(res2)) {
      SWIG_exception_fail(SWIG_ArgError(res2), Ruby_Format_TypeError( "", "Ogre::TerrainMaterialGeneratorPtr","setDefaultMaterialGenerator", 2, argv[0] )); 
    }  
    if (!argp2) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::TerrainMaterialGeneratorPtr","setDefaultMaterialGenerator", 2, argv[0]));
    } else {
      arg2 = *(reinterpret_cast< Ogre::TerrainMaterialGeneratorPtr * >(argp2));
    }
  }
  (arg1)->setDefaultMaterialGenerator(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getLayerBlendMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getLayerBlendMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::uint16)(arg1)->getLayerBlendMapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setLayerBlendMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setLayerBlendMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setLayerBlendMapSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setLayerBlendMapSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getDefaultLayerTextureWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getDefaultLayerTextureWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::Real)(arg1)->getDefaultLayerTextureWorldSize();
  vresult = SWIG_From_float(static_cast< float >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setDefaultLayerTextureWorldSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::Real arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  float 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setDefaultLayerTextureWorldSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_float(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::Real","setDefaultLayerTextureWorldSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::Real >(val2);
  (arg1)->setDefaultLayerTextureWorldSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getDefaultGlobalColourMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getDefaultGlobalColourMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::uint16)(arg1)->getDefaultGlobalColourMapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setDefaultGlobalColourMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setDefaultGlobalColourMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setDefaultGlobalColourMapSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setDefaultGlobalColourMapSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getLightMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getLightMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::uint16)(arg1)->getLightMapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setLightMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setLightMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setLightMapSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setLightMapSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getCompositeMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::uint16 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getCompositeMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::uint16)(arg1)->getCompositeMapSize();
  vresult = SWIG_From_unsigned_SS_short(static_cast< unsigned short >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setCompositeMapSize(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::uint16 arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  unsigned short 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setCompositeMapSize", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_unsigned_SS_short(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "Ogre::uint16","setCompositeMapSize", 2, argv[0] ));
  } 
  arg2 = static_cast< Ogre::uint16 >(val2);
  (arg1)->setCompositeMapSize(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setDefaultResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  Ogre::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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setDefaultResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(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( "", "Ogre::String const &","setDefaultResourceGroup", 2, argv[0] )); 
    }
    if (!ptr) {
      SWIG_exception_fail(SWIG_ValueError, Ruby_Format_TypeError("invalid null reference ", "Ogre::String const &","setDefaultResourceGroup", 2, argv[0])); 
    }
    arg2 = ptr;
  }
  (arg1)->setDefaultResourceGroup((Ogre::String const &)*arg2);
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
fail:
  if (SWIG_IsNewObj(res2)) delete arg2;
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getDefaultResourceGroup(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  Ogre::String *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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","getDefaultResourceGroup", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (Ogre::String *) &(arg1)->getDefaultResourceGroup();
  vresult = SWIG_From_std_string(static_cast< std::string >(*result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getUseVertexCompressionWhenAvailable(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions const *","getUseVertexCompressionWhenAvailable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  result = (bool)((Ogre::TerrainGlobalOptions const *)arg1)->getUseVertexCompressionWhenAvailable();
  vresult = SWIG_From_bool(static_cast< bool >(result));
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_setUseVertexCompressionWhenAvailable(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *arg1 = (Ogre::TerrainGlobalOptions *) 0 ;
  bool arg2 ;
  void *argp1 = 0 ;
  int res1 = 0 ;
  bool 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_Ogre__TerrainGlobalOptions, 0 |  0 );
  if (!SWIG_IsOK(res1)) {
    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "Ogre::TerrainGlobalOptions *","setUseVertexCompressionWhenAvailable", 1, self )); 
  }
  arg1 = reinterpret_cast< Ogre::TerrainGlobalOptions * >(argp1);
  ecode2 = SWIG_AsVal_bool(argv[0], &val2);
  if (!SWIG_IsOK(ecode2)) {
    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "bool","setUseVertexCompressionWhenAvailable", 2, argv[0] ));
  } 
  arg2 = static_cast< bool >(val2);
  (arg1)->setUseVertexCompressionWhenAvailable(arg2);
  return Qnil;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getSingleton(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainGlobalOptions *) &Ogre::TerrainGlobalOptions::getSingleton();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainGlobalOptions, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}


SWIGINTERN VALUE
_wrap_TerrainGlobalOptions_getSingletonPtr(int argc, VALUE *argv, VALUE self) {
  Ogre::TerrainGlobalOptions *result = 0 ;
  VALUE vresult = Qnil;
  
  if ((argc < 0) || (argc > 0)) {
    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0)",argc); SWIG_fail;
  }
  result = (Ogre::TerrainGlobalOptions *)Ogre::TerrainGlobalOptions::getSingletonPtr();
  vresult = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_Ogre__TerrainGlobalOptions, 0 |  0 );
  return vresult;
fail:
  return Qnil;
}



/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__HighLevelGpuProgram(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HighLevelGpuProgram *)  ((Ogre::UnifiedHighLevelGpuProgram *) x));
}
static void *_p_Ogre__HighLevelGpuProgramTo_p_Ogre__GpuProgram(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::GpuProgram *)  ((Ogre::HighLevelGpuProgram *) x));
}
static void *_p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__GpuProgram(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::GpuProgram *) (Ogre::HighLevelGpuProgram *) ((Ogre::UnifiedHighLevelGpuProgram *) x));
}
static void *_p_Ogre__TempBlendedBufferInfoTo_p_Ogre__HardwareBufferLicensee(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBufferLicensee *)  ((Ogre::TempBlendedBufferInfo *) x));
}
static void *_p_Ogre__BoneTo_p_Ogre__Node(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Node *)  ((Ogre::Bone *) x));
}
static void *_p_Ogre__TagPointTo_p_Ogre__Node(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Node *) (Ogre::Bone *) ((Ogre::TagPoint *) x));
}
static void *_p_Ogre__SceneNodeTo_p_Ogre__Node(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Node *)  ((Ogre::SceneNode *) x));
}
static void *_p_Ogre__MemoryDataStreamTo_p_Ogre__DataStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::DataStream *)  ((Ogre::MemoryDataStream *) x));
}
static void *_p_Ogre__FileStreamDataStreamTo_p_Ogre__DataStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::DataStream *)  ((Ogre::FileStreamDataStream *) x));
}
static void *_p_Ogre__FileHandleDataStreamTo_p_Ogre__DataStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::DataStream *)  ((Ogre::FileHandleDataStream *) x));
}
static void *_p_Ogre__DeflateStreamTo_p_Ogre__DataStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::DataStream *)  ((Ogre::DeflateStream *) x));
}
static void *_p_Ogre__ZipDataStreamTo_p_Ogre__DataStream(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::DataStream *)  ((Ogre::ZipDataStream *) x));
}
static void *_p_Ogre__ExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *)  ((Ogre::Exception *) x));
}
static void *_p_Ogre__UnimplementedExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::UnimplementedException *) x));
}
static void *_p_Ogre__FileNotFoundExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::FileNotFoundException *) x));
}
static void *_p_Ogre__IOExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::IOException *) x));
}
static void *_p_Ogre__InvalidStateExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::InvalidStateException *) x));
}
static void *_p_Ogre__InvalidParametersExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::InvalidParametersException *) x));
}
static void *_p_Ogre__ItemIdentityExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::ItemIdentityException *) x));
}
static void *_p_Ogre__InternalErrorExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::InternalErrorException *) x));
}
static void *_p_Ogre__RenderingAPIExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::RenderingAPIException *) x));
}
static void *_p_Ogre__RuntimeAssertionExceptionTo_p_std__exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((std::exception *) (Ogre::Exception *) ((Ogre::RuntimeAssertionException *) x));
}
static void *_p_Ogre__UnimplementedExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::UnimplementedException *) x));
}
static void *_p_Ogre__FileNotFoundExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::FileNotFoundException *) x));
}
static void *_p_Ogre__IOExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::IOException *) x));
}
static void *_p_Ogre__InvalidStateExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::InvalidStateException *) x));
}
static void *_p_Ogre__InvalidParametersExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::InvalidParametersException *) x));
}
static void *_p_Ogre__ItemIdentityExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::ItemIdentityException *) x));
}
static void *_p_Ogre__InternalErrorExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::InternalErrorException *) x));
}
static void *_p_Ogre__RenderingAPIExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::RenderingAPIException *) x));
}
static void *_p_Ogre__RuntimeAssertionExceptionTo_p_Ogre__Exception(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Exception *)  ((Ogre::RuntimeAssertionException *) x));
}
static void *_p_Ogre__CompositorChainTo_p_Ogre__RenderTargetListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RenderTargetListener *)  ((Ogre::CompositorChain *) x));
}
static void *_p_Ogre__FrameTimeControllerValueTo_p_Ogre__FrameListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::FrameListener *)  ((Ogre::FrameTimeControllerValue *) x));
}
static void *_p_Ogre__RegionSceneQueryTo_p_Ogre__SceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQueryListener *)  ((Ogre::RegionSceneQuery *) x));
}
static void *_p_Ogre__AxisAlignedBoxSceneQueryTo_p_Ogre__SceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQueryListener *) (Ogre::RegionSceneQuery *) ((Ogre::AxisAlignedBoxSceneQuery *) x));
}
static void *_p_Ogre__SphereSceneQueryTo_p_Ogre__SceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQueryListener *) (Ogre::RegionSceneQuery *) ((Ogre::SphereSceneQuery *) x));
}
static void *_p_Ogre__PlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQueryListener *) (Ogre::RegionSceneQuery *) ((Ogre::PlaneBoundedVolumeListSceneQuery *) x));
}
static void *_p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__SceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQueryListener *) (Ogre::RegionSceneQuery *)(Ogre::SphereSceneQuery *) ((Ogre::DefaultSphereSceneQuery *) x));
}
static void *_p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQueryListener *) (Ogre::RegionSceneQuery *)(Ogre::PlaneBoundedVolumeListSceneQuery *) ((Ogre::DefaultPlaneBoundedVolumeListSceneQuery *) x));
}
static void *_p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__SceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQueryListener *) (Ogre::RegionSceneQuery *)(Ogre::AxisAlignedBoxSceneQuery *) ((Ogre::DefaultAxisAlignedBoxSceneQuery *) x));
}
static void *_p_Ogre__RaySceneQueryTo_p_Ogre__RaySceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RaySceneQueryListener *)  ((Ogre::RaySceneQuery *) x));
}
static void *_p_Ogre__DefaultRaySceneQueryTo_p_Ogre__RaySceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RaySceneQueryListener *) (Ogre::RaySceneQuery *) ((Ogre::DefaultRaySceneQuery *) x));
}
static void *_p_Ogre__IntersectionSceneQueryTo_p_Ogre__IntersectionSceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::IntersectionSceneQueryListener *)  ((Ogre::IntersectionSceneQuery *) x));
}
static void *_p_Ogre__DefaultIntersectionSceneQueryTo_p_Ogre__IntersectionSceneQueryListener(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::IntersectionSceneQueryListener *) (Ogre::IntersectionSceneQuery *) ((Ogre::DefaultIntersectionSceneQuery *) x));
}
static void *_p_Ogre__SimplePageContentCollectionTo_p_Ogre__PageContentCollection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PageContentCollection *)  ((Ogre::SimplePageContentCollection *) x));
}
static void *_p_Ogre__MovablePlaneTo_p_Ogre__Plane(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Plane *)  ((Ogre::MovablePlane *) x));
}
static void *_p_Ogre__NumericAnimationTrackTo_p_Ogre__AnimationTrack(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimationTrack *)  ((Ogre::NumericAnimationTrack *) x));
}
static void *_p_Ogre__NodeAnimationTrackTo_p_Ogre__AnimationTrack(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimationTrack *)  ((Ogre::NodeAnimationTrack *) x));
}
static void *_p_Ogre__VertexAnimationTrackTo_p_Ogre__AnimationTrack(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimationTrack *)  ((Ogre::VertexAnimationTrack *) x));
}
static void *_p_Ogre__BillboardParticleRendererTo_p_Ogre__ParticleSystemRenderer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParticleSystemRenderer *)  ((Ogre::BillboardParticleRenderer *) x));
}
static void *_p_Ogre__WireBoundingBoxTo_p_Ogre__SimpleRenderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SimpleRenderable *)  ((Ogre::WireBoundingBox *) x));
}
static void *_p_Ogre__InstanceBatchVTFTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchVTF *) x));
}
static void *_p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::InstanceBatch *) ((Ogre::BaseInstanceBatchVTF *) x));
}
static void *_p_Ogre__BillboardChainTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::BillboardChain *) x));
}
static void *_p_Ogre__BorderRenderableTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::BorderRenderable *) x));
}
static void *_p_Ogre__ShadowRenderableTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::ShadowRenderable *) x));
}
static void *_p_Ogre__SimpleRenderableTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::SimpleRenderable *) x));
}
static void *_p_Ogre__CameraTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::Frustum *) ((Ogre::Camera *) x));
}
static void *_p_Ogre__WireBoundingBoxTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::SimpleRenderable *) ((Ogre::WireBoundingBox *) x));
}
static void *_p_Ogre__InstanceBatchHWTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::InstanceBatch *) ((Ogre::InstanceBatchHW *) x));
}
static void *_p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchHW_VTF *) x));
}
static void *_p_Ogre__OverlayContainerTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::OverlayElement *) ((Ogre::OverlayContainer *) x));
}
static void *_p_Ogre__SubEntityTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::SubEntity *) x));
}
static void *_p_Ogre__BillboardSetTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::BillboardSet *) x));
}
static void *_p_Ogre__InstanceBatchTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::InstanceBatch *) x));
}
static void *_p_Ogre__FrustumTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::Frustum *) x));
}
static void *_p_Ogre__BorderPanelOverlayElementTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::OverlayElement *)(Ogre::OverlayContainer *)(Ogre::PanelOverlayElement *) ((Ogre::BorderPanelOverlayElement *) x));
}
static void *_p_Ogre__PanelOverlayElementTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::OverlayElement *)(Ogre::OverlayContainer *) ((Ogre::PanelOverlayElement *) x));
}
static void *_p_Ogre__OverlayElementTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *)  ((Ogre::OverlayElement *) x));
}
static void *_p_Ogre__InstanceBatchShaderTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::InstanceBatch *) ((Ogre::InstanceBatchShader *) x));
}
static void *_p_Ogre__TextAreaOverlayElementTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::OverlayElement *) ((Ogre::TextAreaOverlayElement *) x));
}
static void *_p_Ogre__RibbonTrailTo_p_Ogre__Renderable(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Renderable *) (Ogre::BillboardChain *) ((Ogre::RibbonTrail *) x));
}
static void *_p_IntpTo_p_int(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((int *)  ((Intp *) x));
}
static void *_p_Ogre__MultiRenderTargetTo_p_Ogre__RenderTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RenderTarget *)  ((Ogre::MultiRenderTarget *) x));
}
static void *_p_Ogre__RenderWindowTo_p_Ogre__RenderTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RenderTarget *)  ((Ogre::RenderWindow *) x));
}
static void *_p_Ogre__RenderTextureTo_p_Ogre__RenderTarget(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RenderTarget *)  ((Ogre::RenderTexture *) x));
}
static void *_p_Ogre__SkeletonInstanceTo_p_Ogre__Skeleton(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Skeleton *)  ((Ogre::SkeletonInstance *) x));
}
static void *_p_Ogre__TagPointTo_p_Ogre__Bone(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Bone *)  ((Ogre::TagPoint *) x));
}
static void *_p_Ogre__InstanceBatchHWTo_p_Ogre__InstanceBatch(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::InstanceBatch *)  ((Ogre::InstanceBatchHW *) x));
}
static void *_p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__InstanceBatch(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::InstanceBatch *) (Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchHW_VTF *) x));
}
static void *_p_Ogre__InstanceBatchShaderTo_p_Ogre__InstanceBatch(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::InstanceBatch *)  ((Ogre::InstanceBatchShader *) x));
}
static void *_p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__InstanceBatch(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::InstanceBatch *)  ((Ogre::BaseInstanceBatchVTF *) x));
}
static void *_p_Ogre__InstanceBatchVTFTo_p_Ogre__InstanceBatch(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::InstanceBatch *) (Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchVTF *) x));
}
static void *_p_Ogre__TerrainPagedWorldSectionTo_p_Ogre__PagedWorldSection(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PagedWorldSection *)  ((Ogre::TerrainPagedWorldSection *) x));
}
static void *_p_Ogre__FileSystemArchiveTo_p_Ogre__Archive(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Archive *)  ((Ogre::FileSystemArchive *) x));
}
static void *_p_Ogre__ZipArchiveTo_p_Ogre__Archive(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Archive *)  ((Ogre::ZipArchive *) x));
}
static void *_p_Ogre__PixelBoxTo_p_Ogre__Box(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Box *)  ((Ogre::PixelBox *) x));
}
static void *_p_Ogre__CompositionPassTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::CompositionPassTranslator *) x));
}
static void *_p_Ogre__CompositionTargetPassTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::CompositionTargetPassTranslator *) x));
}
static void *_p_Ogre__CompositionTechniqueTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::CompositionTechniqueTranslator *) x));
}
static void *_p_Ogre__CompositorTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::CompositorTranslator *) x));
}
static void *_p_Ogre__ParticleAffectorTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::ParticleAffectorTranslator *) x));
}
static void *_p_Ogre__ParticleEmitterTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::ParticleEmitterTranslator *) x));
}
static void *_p_Ogre__ParticleSystemTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::ParticleSystemTranslator *) x));
}
static void *_p_Ogre__SharedParamsTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::SharedParamsTranslator *) x));
}
static void *_p_Ogre__GpuProgramTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::GpuProgramTranslator *) x));
}
static void *_p_Ogre__TextureSourceTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::TextureSourceTranslator *) x));
}
static void *_p_Ogre__TextureUnitTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::TextureUnitTranslator *) x));
}
static void *_p_Ogre__PassTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::PassTranslator *) x));
}
static void *_p_Ogre__TechniqueTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::TechniqueTranslator *) x));
}
static void *_p_Ogre__MaterialTranslatorTo_p_Ogre__ScriptTranslator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslator *)  ((Ogre::MaterialTranslator *) x));
}
static void *_p_Ogre__MaterialManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::MaterialManager *) x));
}
static void *_p_Ogre__TextureManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::TextureManager *) x));
}
static void *_p_Ogre__CompositorManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::CompositorManager *) x));
}
static void *_p_Ogre__FontManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::FontManager *) x));
}
static void *_p_Ogre__GpuProgramManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::GpuProgramManager *) x));
}
static void *_p_Ogre__HighLevelGpuProgramManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::HighLevelGpuProgramManager *) x));
}
static void *_p_Ogre__MeshManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::MeshManager *) x));
}
static void *_p_Ogre__SkeletonManagerTo_p_Ogre__ResourceManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ResourceManager *)  ((Ogre::SkeletonManager *) x));
}
static void *_p_Ogre__DefaultHardwareBufferManagerTo_p_Ogre__HardwareBufferManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBufferManager *)  ((Ogre::DefaultHardwareBufferManager *) x));
}
static void *_p_Ogre__DefaultSceneManagerTo_p_Ogre__SceneManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneManager *)  ((Ogre::DefaultSceneManager *) x));
}
static void *_p_Ogre__BuiltinScriptTranslatorManagerTo_p_Ogre__ScriptTranslatorManager(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptTranslatorManager *)  ((Ogre::BuiltinScriptTranslatorManager *) x));
}
static void *_p_Ogre__ParticleEmitterTo_p_Ogre__Particle(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Particle *)  ((Ogre::ParticleEmitter *) x));
}
static void *_p_Ogre__BorderPanelOverlayElementTo_p_Ogre__PanelOverlayElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PanelOverlayElement *)  ((Ogre::BorderPanelOverlayElement *) x));
}
static void *_p_Ogre__PanelOverlayElementTo_p_Ogre__OverlayElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayElement *) (Ogre::OverlayContainer *) ((Ogre::PanelOverlayElement *) x));
}
static void *_p_Ogre__BorderPanelOverlayElementTo_p_Ogre__OverlayElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayElement *) (Ogre::OverlayContainer *)(Ogre::PanelOverlayElement *) ((Ogre::BorderPanelOverlayElement *) x));
}
static void *_p_Ogre__TextAreaOverlayElementTo_p_Ogre__OverlayElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayElement *)  ((Ogre::TextAreaOverlayElement *) x));
}
static void *_p_Ogre__OverlayContainerTo_p_Ogre__OverlayElement(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayElement *)  ((Ogre::OverlayContainer *) x));
}
static void *_p_Ogre__RibbonTrailTo_p_Ogre__BillboardChain(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::BillboardChain *)  ((Ogre::RibbonTrail *) x));
}
static void *_p_Ogre__SimplePageContentCollectionFactoryTo_p_Ogre__PageContentCollectionFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PageContentCollectionFactory *)  ((Ogre::SimplePageContentCollectionFactory *) x));
}
static void *_p_Ogre__EmbeddedZipArchiveFactoryTo_p_Ogre__ZipArchiveFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ZipArchiveFactory *)  ((Ogre::EmbeddedZipArchiveFactory *) x));
}
static void *_p_Ogre__UnifiedHighLevelGpuProgramFactoryTo_p_Ogre__HighLevelGpuProgramFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HighLevelGpuProgramFactory *)  ((Ogre::UnifiedHighLevelGpuProgramFactory *) x));
}
static void *_p_Ogre__BillboardParticleRendererFactoryTo_p_Ogre__ParticleSystemRendererFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParticleSystemRendererFactory *)  ((Ogre::BillboardParticleRendererFactory *) x));
}
static void *_p_Ogre__LightFactoryTo_p_Ogre__MovableObjectFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObjectFactory *)  ((Ogre::LightFactory *) x));
}
static void *_p_Ogre__BillboardChainFactoryTo_p_Ogre__MovableObjectFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObjectFactory *)  ((Ogre::BillboardChainFactory *) x));
}
static void *_p_Ogre__BillboardSetFactoryTo_p_Ogre__MovableObjectFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObjectFactory *)  ((Ogre::BillboardSetFactory *) x));
}
static void *_p_Ogre__EntityFactoryTo_p_Ogre__MovableObjectFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObjectFactory *)  ((Ogre::EntityFactory *) x));
}
static void *_p_Ogre__ManualObjectFactoryTo_p_Ogre__MovableObjectFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObjectFactory *)  ((Ogre::ManualObjectFactory *) x));
}
static void *_p_Ogre__ParticleSystemFactoryTo_p_Ogre__MovableObjectFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObjectFactory *)  ((Ogre::ParticleSystemFactory *) x));
}
static void *_p_Ogre__RibbonTrailFactoryTo_p_Ogre__MovableObjectFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObjectFactory *)  ((Ogre::RibbonTrailFactory *) x));
}
static void *_p_Ogre__FileSystemArchiveFactoryTo_p_Ogre__ArchiveFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ArchiveFactory *)  ((Ogre::FileSystemArchiveFactory *) x));
}
static void *_p_Ogre__ZipArchiveFactoryTo_p_Ogre__ArchiveFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ArchiveFactory *)  ((Ogre::ZipArchiveFactory *) x));
}
static void *_p_Ogre__EmbeddedZipArchiveFactoryTo_p_Ogre__ArchiveFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ArchiveFactory *) (Ogre::ZipArchiveFactory *) ((Ogre::EmbeddedZipArchiveFactory *) x));
}
static void *_p_Ogre__PanelOverlayElementFactoryTo_p_Ogre__OverlayElementFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayElementFactory *)  ((Ogre::PanelOverlayElementFactory *) x));
}
static void *_p_Ogre__BorderPanelOverlayElementFactoryTo_p_Ogre__OverlayElementFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayElementFactory *)  ((Ogre::BorderPanelOverlayElementFactory *) x));
}
static void *_p_Ogre__TextAreaOverlayElementFactoryTo_p_Ogre__OverlayElementFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayElementFactory *)  ((Ogre::TextAreaOverlayElementFactory *) x));
}
static void *_p_Ogre__DefaultSceneManagerFactoryTo_p_Ogre__SceneManagerFactory(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneManagerFactory *)  ((Ogre::DefaultSceneManagerFactory *) x));
}
static void *_p_Ogre__InstanceBatchVTFTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchVTF *) x));
}
static void *_p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::InstanceBatch *) ((Ogre::BaseInstanceBatchVTF *) x));
}
static void *_p_Ogre__ManualObjectTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::ManualObject *) x));
}
static void *_p_Ogre__BillboardChainTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::BillboardChain *) x));
}
static void *_p_Ogre__SimpleRenderableTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::SimpleRenderable *) x));
}
static void *_p_Ogre__CameraTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::Frustum *) ((Ogre::Camera *) x));
}
static void *_p_Ogre__WireBoundingBoxTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::SimpleRenderable *) ((Ogre::WireBoundingBox *) x));
}
static void *_p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchHW_VTF *) x));
}
static void *_p_Ogre__InstanceBatchHWTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::InstanceBatch *) ((Ogre::InstanceBatchHW *) x));
}
static void *_p_Ogre__ParticleSystemTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::ParticleSystem *) x));
}
static void *_p_Ogre__MovablePlaneTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::MovablePlane *) x));
}
static void *_p_Ogre__InstancedEntityTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::InstancedEntity *) x));
}
static void *_p_Ogre__EntityTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::Entity *) x));
}
static void *_p_Ogre__LightTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::Light *) x));
}
static void *_p_Ogre__BillboardSetTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::BillboardSet *) x));
}
static void *_p_Ogre__InstanceBatchTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::InstanceBatch *) x));
}
static void *_p_Ogre__InstanceBatchShaderTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::InstanceBatch *) ((Ogre::InstanceBatchShader *) x));
}
static void *_p_Ogre__FrustumTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *)  ((Ogre::Frustum *) x));
}
static void *_p_Ogre__RibbonTrailTo_p_Ogre__MovableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::MovableObject *) (Ogre::BillboardChain *) ((Ogre::RibbonTrail *) x));
}
static void *_p_Ogre__InstanceBatchVTFTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchVTF *) x));
}
static void *_p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::InstanceBatch *) ((Ogre::BaseInstanceBatchVTF *) x));
}
static void *_p_Ogre__ManualObjectTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::ManualObject *) x));
}
static void *_p_Ogre__BillboardChainTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::BillboardChain *) x));
}
static void *_p_Ogre__SimpleRenderableTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::SimpleRenderable *) x));
}
static void *_p_Ogre__CameraTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::Frustum *) ((Ogre::Camera *) x));
}
static void *_p_Ogre__WireBoundingBoxTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::SimpleRenderable *) ((Ogre::WireBoundingBox *) x));
}
static void *_p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchHW_VTF *) x));
}
static void *_p_Ogre__InstanceBatchHWTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::InstanceBatch *) ((Ogre::InstanceBatchHW *) x));
}
static void *_p_Ogre__ParticleSystemTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::ParticleSystem *) x));
}
static void *_p_Ogre__MovablePlaneTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::MovablePlane *) x));
}
static void *_p_Ogre__EntityTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::Entity *) x));
}
static void *_p_Ogre__InstancedEntityTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::InstancedEntity *) x));
}
static void *_p_Ogre__LightTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::Light *) x));
}
static void *_p_Ogre__BillboardSetTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::BillboardSet *) x));
}
static void *_p_Ogre__InstanceBatchTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::InstanceBatch *) x));
}
static void *_p_Ogre__MovableObjectTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *)  ((Ogre::MovableObject *) x));
}
static void *_p_Ogre__InstanceBatchShaderTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::InstanceBatch *) ((Ogre::InstanceBatchShader *) x));
}
static void *_p_Ogre__FrustumTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *) ((Ogre::Frustum *) x));
}
static void *_p_Ogre__RibbonTrailTo_p_Ogre__AnimableObject(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimableObject *) (Ogre::MovableObject *)(Ogre::BillboardChain *) ((Ogre::RibbonTrail *) x));
}
static void *_p_Ogre__PanelOverlayElementTo_p_Ogre__OverlayContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayContainer *)  ((Ogre::PanelOverlayElement *) x));
}
static void *_p_Ogre__BorderPanelOverlayElementTo_p_Ogre__OverlayContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::OverlayContainer *) (Ogre::PanelOverlayElement *) ((Ogre::BorderPanelOverlayElement *) x));
}
static void *_p_Ogre__MeshTo_p_Ogre__AnimationContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimationContainer *)  ((Ogre::Mesh *) x));
}
static void *_p_Ogre__SkeletonInstanceTo_p_Ogre__AnimationContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimationContainer *) (Ogre::Skeleton *) ((Ogre::SkeletonInstance *) x));
}
static void *_p_Ogre__SkeletonTo_p_Ogre__AnimationContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimationContainer *)  ((Ogre::Skeleton *) x));
}
static void *_p_Ogre__PatchMeshTo_p_Ogre__AnimationContainer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AnimationContainer *) (Ogre::Mesh *) ((Ogre::PatchMesh *) x));
}
static void *_p_Ogre__Grid2DPageStrategyTo_p_Ogre__PageStrategy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PageStrategy *)  ((Ogre::Grid2DPageStrategy *) x));
}
static void *_p_Ogre__Grid3DPageStrategyTo_p_Ogre__PageStrategy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PageStrategy *)  ((Ogre::Grid3DPageStrategy *) x));
}
static void *_p_Ogre__DistanceLodStrategyTo_p_Ogre__LodStrategy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::LodStrategy *)  ((Ogre::DistanceLodStrategy *) x));
}
static void *_p_Ogre__PixelCountLodStrategyTo_p_Ogre__LodStrategy(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::LodStrategy *)  ((Ogre::PixelCountLodStrategy *) x));
}
static void *_p_Ogre__ImageCodecTo_p_Ogre__Codec(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Codec *)  ((Ogre::ImageCodec *) x));
}
static void *_p_Ogre__DDSCodecTo_p_Ogre__Codec(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Codec *) (Ogre::ImageCodec *) ((Ogre::DDSCodec *) x));
}
static void *_p_Ogre__FreeImageCodecTo_p_Ogre__Codec(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Codec *) (Ogre::ImageCodec *) ((Ogre::FreeImageCodec *) x));
}
static void *_p_Ogre__Grid2DPageStrategyDataTo_p_Ogre__PageStrategyData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PageStrategyData *)  ((Ogre::Grid2DPageStrategyData *) x));
}
static void *_p_Ogre__Grid3DPageStrategyDataTo_p_Ogre__PageStrategyData(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PageStrategyData *)  ((Ogre::Grid3DPageStrategyData *) x));
}
static void *_p_Ogre__CameraTo_p_Ogre__Frustum(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Frustum *)  ((Ogre::Camera *) x));
}
static void *_p_Ogre__PreApplyTextureAliasesScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::PreApplyTextureAliasesScriptCompilerEvent *) x));
}
static void *_p_Ogre__ProcessResourceNameScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::ProcessResourceNameScriptCompilerEvent *) x));
}
static void *_p_Ogre__ProcessNameExclusionScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::ProcessNameExclusionScriptCompilerEvent *) x));
}
static void *_p_Ogre__CreateMaterialScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::CreateMaterialScriptCompilerEvent *) x));
}
static void *_p_Ogre__CreateGpuProgramScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::CreateGpuProgramScriptCompilerEvent *) x));
}
static void *_p_Ogre__CreateHighLevelGpuProgramScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *) x));
}
static void *_p_Ogre__CreateGpuSharedParametersScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::CreateGpuSharedParametersScriptCompilerEvent *) x));
}
static void *_p_Ogre__CreateParticleSystemScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::CreateParticleSystemScriptCompilerEvent *) x));
}
static void *_p_Ogre__CreateCompositorScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptCompilerEvent *)  ((Ogre::CreateCompositorScriptCompilerEvent *) x));
}
static void *_p_Ogre__HardwareVertexBufferTo_p_Ogre__HardwareBuffer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBuffer *)  ((Ogre::HardwareVertexBuffer *) x));
}
static void *_p_Ogre__HardwareIndexBufferTo_p_Ogre__HardwareBuffer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBuffer *)  ((Ogre::HardwareIndexBuffer *) x));
}
static void *_p_Ogre__DefaultHardwareVertexBufferTo_p_Ogre__HardwareBuffer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBuffer *) (Ogre::HardwareVertexBuffer *) ((Ogre::DefaultHardwareVertexBuffer *) x));
}
static void *_p_Ogre__DefaultHardwareIndexBufferTo_p_Ogre__HardwareBuffer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBuffer *) (Ogre::HardwareIndexBuffer *) ((Ogre::DefaultHardwareIndexBuffer *) x));
}
static void *_p_Ogre__HardwarePixelBufferTo_p_Ogre__HardwareBuffer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBuffer *)  ((Ogre::HardwarePixelBuffer *) x));
}
static void *_p_Ogre__InstanceBatchVTFTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchVTF *) x));
}
static void *_p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::InstanceBatch *) ((Ogre::BaseInstanceBatchVTF *) x));
}
static void *_p_Ogre__ManualObjectTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::ManualObject *) x));
}
static void *_p_Ogre__BillboardChainTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::BillboardChain *) x));
}
static void *_p_Ogre__SimpleRenderableTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::SimpleRenderable *) x));
}
static void *_p_Ogre__CameraTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::Frustum *) ((Ogre::Camera *) x));
}
static void *_p_Ogre__WireBoundingBoxTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::SimpleRenderable *) ((Ogre::WireBoundingBox *) x));
}
static void *_p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::InstanceBatch *)(Ogre::BaseInstanceBatchVTF *) ((Ogre::InstanceBatchHW_VTF *) x));
}
static void *_p_Ogre__InstanceBatchHWTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::InstanceBatch *) ((Ogre::InstanceBatchHW *) x));
}
static void *_p_Ogre__ParticleSystemTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::ParticleSystem *) x));
}
static void *_p_Ogre__MovablePlaneTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::MovablePlane *) x));
}
static void *_p_Ogre__EntityTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::Entity *) x));
}
static void *_p_Ogre__InstancedEntityTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::InstancedEntity *) x));
}
static void *_p_Ogre__LightTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::Light *) x));
}
static void *_p_Ogre__BillboardSetTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::BillboardSet *) x));
}
static void *_p_Ogre__InstanceBatchTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::InstanceBatch *) x));
}
static void *_p_Ogre__MovableObjectTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *)  ((Ogre::MovableObject *) x));
}
static void *_p_Ogre__InstanceBatchShaderTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::InstanceBatch *) ((Ogre::InstanceBatchShader *) x));
}
static void *_p_Ogre__FrustumTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *) ((Ogre::Frustum *) x));
}
static void *_p_Ogre__RibbonTrailTo_p_Ogre__ShadowCaster(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCaster *) (Ogre::MovableObject *)(Ogre::BillboardChain *) ((Ogre::RibbonTrail *) x));
}
static void *_p_Ogre__GpuNamedConstantsSerializerTo_p_Ogre__Serializer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Serializer *)  ((Ogre::GpuNamedConstantsSerializer *) x));
}
static void *_p_Ogre__MeshSerializerTo_p_Ogre__Serializer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Serializer *)  ((Ogre::MeshSerializer *) x));
}
static void *_p_Ogre__SkeletonSerializerTo_p_Ogre__Serializer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Serializer *)  ((Ogre::SkeletonSerializer *) x));
}
static void *_p_Ogre__MaterialPtrTo_p_Ogre__SharedPtrT_Ogre__Material_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SharedPtr< Ogre::Material > *)  ((Ogre::MaterialPtr *) x));
}
static void *_p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__BaseInstanceBatchVTF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::BaseInstanceBatchVTF *)  ((Ogre::InstanceBatchHW_VTF *) x));
}
static void *_p_Ogre__InstanceBatchVTFTo_p_Ogre__BaseInstanceBatchVTF(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::BaseInstanceBatchVTF *)  ((Ogre::InstanceBatchVTF *) x));
}
static void *_p_Ogre__PatchMeshTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *)(Ogre::Mesh *) ((Ogre::PatchMesh *) x));
}
static void *_p_Ogre__CompositorTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *) ((Ogre::Compositor *) x));
}
static void *_p_Ogre__SkeletonTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *) ((Ogre::Skeleton *) x));
}
static void *_p_Ogre__MaterialTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *) ((Ogre::Material *) x));
}
static void *_p_Ogre__ExternalTextureSourceTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *)  ((Ogre::ExternalTextureSource *) x));
}
static void *_p_Ogre__ParticleSystemTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *)  ((Ogre::ParticleSystem *) x));
}
static void *_p_Ogre__OverlayContainerTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::OverlayElement *) ((Ogre::OverlayContainer *) x));
}
static void *_p_Ogre__GpuProgramTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *) ((Ogre::GpuProgram *) x));
}
static void *_p_Ogre__FontTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *) ((Ogre::Font *) x));
}
static void *_p_Ogre__HighLevelGpuProgramTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *)(Ogre::GpuProgram *) ((Ogre::HighLevelGpuProgram *) x));
}
static void *_p_Ogre__SkeletonInstanceTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *)(Ogre::Skeleton *) ((Ogre::SkeletonInstance *) x));
}
static void *_p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *)(Ogre::GpuProgram *)(Ogre::HighLevelGpuProgram *) ((Ogre::UnifiedHighLevelGpuProgram *) x));
}
static void *_p_Ogre__TextureTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *) ((Ogre::Texture *) x));
}
static void *_p_Ogre__ResourceTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *)  ((Ogre::Resource *) x));
}
static void *_p_Ogre__MeshTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::Resource *) ((Ogre::Mesh *) x));
}
static void *_p_Ogre__BorderPanelOverlayElementTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::OverlayElement *)(Ogre::OverlayContainer *)(Ogre::PanelOverlayElement *) ((Ogre::BorderPanelOverlayElement *) x));
}
static void *_p_Ogre__PanelOverlayElementTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::OverlayElement *)(Ogre::OverlayContainer *) ((Ogre::PanelOverlayElement *) x));
}
static void *_p_Ogre__OverlayElementTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *)  ((Ogre::OverlayElement *) x));
}
static void *_p_Ogre__TextAreaOverlayElementTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::OverlayElement *) ((Ogre::TextAreaOverlayElement *) x));
}
static void *_p_Ogre__BillboardParticleRendererTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *) (Ogre::ParticleSystemRenderer *) ((Ogre::BillboardParticleRenderer *) x));
}
static void *_p_Ogre__ParticleSystemRendererTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *)  ((Ogre::ParticleSystemRenderer *) x));
}
static void *_p_Ogre__ParticleAffectorTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *)  ((Ogre::ParticleAffector *) x));
}
static void *_p_Ogre__ParticleEmitterTo_p_Ogre__StringInterface(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::StringInterface *)  ((Ogre::ParticleEmitter *) x));
}
static void *_p_Ogre__DefaultHardwareVertexBufferTo_p_Ogre__HardwareVertexBuffer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareVertexBuffer *)  ((Ogre::DefaultHardwareVertexBuffer *) x));
}
static void *_p_Ogre__DefaultHardwareIndexBufferTo_p_Ogre__HardwareIndexBuffer(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareIndexBuffer *)  ((Ogre::DefaultHardwareIndexBuffer *) x));
}
static void *_p_Ogre__MeshManagerTo_p_Ogre__ManualResourceLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ManualResourceLoader *)  ((Ogre::MeshManager *) x));
}
static void *_p_Ogre__FontTo_p_Ogre__ManualResourceLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ManualResourceLoader *)  ((Ogre::Font *) x));
}
static void *_p_Ogre__DDSCodecTo_p_Ogre__ImageCodec(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ImageCodec *)  ((Ogre::DDSCodec *) x));
}
static void *_p_Ogre__FreeImageCodecTo_p_Ogre__ImageCodec(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ImageCodec *)  ((Ogre::FreeImageCodec *) x));
}
static void *_p_Ogre__AtomAbstractNodeTo_p_Ogre__AbstractNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AbstractNode *)  ((Ogre::AtomAbstractNode *) x));
}
static void *_p_Ogre__ObjectAbstractNodeTo_p_Ogre__AbstractNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AbstractNode *)  ((Ogre::ObjectAbstractNode *) x));
}
static void *_p_Ogre__PropertyAbstractNodeTo_p_Ogre__AbstractNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AbstractNode *)  ((Ogre::PropertyAbstractNode *) x));
}
static void *_p_Ogre__ImportAbstractNodeTo_p_Ogre__AbstractNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AbstractNode *)  ((Ogre::ImportAbstractNode *) x));
}
static void *_p_Ogre__VariableAccessAbstractNodeTo_p_Ogre__AbstractNode(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AbstractNode *)  ((Ogre::VariableAccessAbstractNode *) x));
}
static void *_p_Ogre__AnyNumericTo_p_Ogre__Any(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Any *)  ((Ogre::AnyNumeric *) x));
}
static void *_p_Ogre__AnyVALUETo_p_Ogre__Any(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Any *)  ((Ogre::AnyVALUE *) x));
}
static void *_p_Ogre__HardwareBufferManagerTo_p_Ogre__HardwareBufferManagerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBufferManagerBase *)  ((Ogre::HardwareBufferManager *) x));
}
static void *_p_Ogre__DefaultHardwareBufferManagerTo_p_Ogre__HardwareBufferManagerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBufferManagerBase *) (Ogre::HardwareBufferManager *) ((Ogre::DefaultHardwareBufferManager *) x));
}
static void *_p_Ogre__DefaultHardwareBufferManagerBaseTo_p_Ogre__HardwareBufferManagerBase(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::HardwareBufferManagerBase *)  ((Ogre::DefaultHardwareBufferManagerBase *) x));
}
static void *_p_Ogre__NumericKeyFrameTo_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame *)  ((Ogre::NumericKeyFrame *) x));
}
static void *_p_Ogre__TransformKeyFrameTo_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame *)  ((Ogre::TransformKeyFrame *) x));
}
static void *_p_Ogre__VertexMorphKeyFrameTo_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame *)  ((Ogre::VertexMorphKeyFrame *) x));
}
static void *_p_Ogre__VertexPoseKeyFrameTo_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame *)  ((Ogre::VertexPoseKeyFrame *) x));
}
static void *_p_p_Ogre__NumericKeyFrameTo_p_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame **)  ((Ogre::NumericKeyFrame **) x));
}
static void *_p_p_Ogre__TransformKeyFrameTo_p_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame **)  ((Ogre::TransformKeyFrame **) x));
}
static void *_p_p_Ogre__VertexMorphKeyFrameTo_p_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame **)  ((Ogre::VertexMorphKeyFrame **) x));
}
static void *_p_p_Ogre__VertexPoseKeyFrameTo_p_p_Ogre__KeyFrame(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::KeyFrame **)  ((Ogre::VertexPoseKeyFrame **) x));
}
static void *_p_swig__IteratorTo_p_swig__ConstIterator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((swig::ConstIterator *)  ((swig::Iterator *) x));
}
static void *_p_Ogre__TerrainMaterialGeneratorATo_p_Ogre__TerrainMaterialGenerator(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::TerrainMaterialGenerator *)  ((Ogre::TerrainMaterialGeneratorA *) x));
}
static void *_p_Ogre__MeshPtrTo_p_Ogre__SharedPtrT_Ogre__Mesh_t(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SharedPtr< Ogre::Mesh > *)  ((Ogre::MeshPtr *) x));
}
static void *_p_Ogre__GpuProgramTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *)  ((Ogre::GpuProgram *) x));
}
static void *_p_Ogre__MeshTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *)  ((Ogre::Mesh *) x));
}
static void *_p_Ogre__CompositorTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *)  ((Ogre::Compositor *) x));
}
static void *_p_Ogre__HighLevelGpuProgramTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *) (Ogre::GpuProgram *) ((Ogre::HighLevelGpuProgram *) x));
}
static void *_p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *) (Ogre::GpuProgram *)(Ogre::HighLevelGpuProgram *) ((Ogre::UnifiedHighLevelGpuProgram *) x));
}
static void *_p_Ogre__SkeletonInstanceTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *) (Ogre::Skeleton *) ((Ogre::SkeletonInstance *) x));
}
static void *_p_Ogre__MaterialTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *)  ((Ogre::Material *) x));
}
static void *_p_Ogre__TextureTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *)  ((Ogre::Texture *) x));
}
static void *_p_Ogre__FontTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *)  ((Ogre::Font *) x));
}
static void *_p_Ogre__SkeletonTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *)  ((Ogre::Skeleton *) x));
}
static void *_p_Ogre__PatchMeshTo_p_Ogre__Resource(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Resource *) (Ogre::Mesh *) ((Ogre::PatchMesh *) x));
}
static void *_p_Ogre__EmitterCommands__CmdColourTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdColour *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdCaptionTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdCaption *) x));
}
static void *_p_Ogre__EmitterCommands__CmdDirectionTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdDirection *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdTopTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdTop *) x));
}
static void *_p_Ogre__EmitterCommands__CmdColourRangeEndTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdColourRangeEnd *) x));
}
static void *_p_Ogre__EmitterCommands__CmdTTLTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdTTL *) x));
}
static void *_p_Ogre__EmitterCommands__CmdColourRangeStartTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdColourRangeStart *) x));
}
static void *_p_Ogre__EmitterCommands__CmdAngleTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdAngle *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdMaterialTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdMaterial *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdHeightTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdHeight *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdLeftTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdLeft *) x));
}
static void *_p_Ogre__EmitterCommands__CmdVelocityTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdVelocity *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMinVelocityTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMinVelocity *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMaxVelocityTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMaxVelocity *) x));
}
static void *_p_Ogre__EmitterCommands__CmdPositionTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdPosition *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdMetricsModeTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdMetricsMode *) x));
}
static void *_p_Ogre__EmitterCommands__CmdUpTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdUp *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMaxTTLTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMaxTTL *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdVerticalAlignTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdVerticalAlign *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdHorizontalAlignTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdHorizontalAlign *) x));
}
static void *_p_Ogre__EmitterCommands__CmdEmissionRateTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdEmissionRate *) x));
}
static void *_p_Ogre__EmitterCommands__CmdNameTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdName *) x));
}
static void *_p_Ogre__EmitterCommands__CmdEmittedEmitterTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdEmittedEmitter *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdVisibleTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdVisible *) x));
}
static void *_p_Ogre__OverlayElementCommands__CmdWidthTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::OverlayElementCommands::CmdWidth *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMinTTLTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMinTTL *) x));
}
static void *_p_Ogre__EmitterCommands__CmdDurationTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdDuration *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMinDurationTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMinDuration *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMaxDurationTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMaxDuration *) x));
}
static void *_p_Ogre__EmitterCommands__CmdRepeatDelayTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdRepeatDelay *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMinRepeatDelayTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMinRepeatDelay *) x));
}
static void *_p_Ogre__EmitterCommands__CmdMaxRepeatDelayTo_p_Ogre__ParamCommand(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ParamCommand *)  ((Ogre::EmitterCommands::CmdMaxRepeatDelay *) x));
}
static void *_p_Ogre__RegionSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *)  ((Ogre::RegionSceneQuery *) x));
}
static void *_p_Ogre__AxisAlignedBoxSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::RegionSceneQuery *) ((Ogre::AxisAlignedBoxSceneQuery *) x));
}
static void *_p_Ogre__SphereSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::RegionSceneQuery *) ((Ogre::SphereSceneQuery *) x));
}
static void *_p_Ogre__PlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::RegionSceneQuery *) ((Ogre::PlaneBoundedVolumeListSceneQuery *) x));
}
static void *_p_Ogre__RaySceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *)  ((Ogre::RaySceneQuery *) x));
}
static void *_p_Ogre__IntersectionSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *)  ((Ogre::IntersectionSceneQuery *) x));
}
static void *_p_Ogre__DefaultIntersectionSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::IntersectionSceneQuery *) ((Ogre::DefaultIntersectionSceneQuery *) x));
}
static void *_p_Ogre__DefaultRaySceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::RaySceneQuery *) ((Ogre::DefaultRaySceneQuery *) x));
}
static void *_p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::RegionSceneQuery *)(Ogre::SphereSceneQuery *) ((Ogre::DefaultSphereSceneQuery *) x));
}
static void *_p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::RegionSceneQuery *)(Ogre::PlaneBoundedVolumeListSceneQuery *) ((Ogre::DefaultPlaneBoundedVolumeListSceneQuery *) x));
}
static void *_p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__SceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SceneQuery *) (Ogre::RegionSceneQuery *)(Ogre::AxisAlignedBoxSceneQuery *) ((Ogre::DefaultAxisAlignedBoxSceneQuery *) x));
}
static void *_p_Ogre__AxisAlignedBoxSceneQueryTo_p_Ogre__RegionSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RegionSceneQuery *)  ((Ogre::AxisAlignedBoxSceneQuery *) x));
}
static void *_p_Ogre__SphereSceneQueryTo_p_Ogre__RegionSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RegionSceneQuery *)  ((Ogre::SphereSceneQuery *) x));
}
static void *_p_Ogre__PlaneBoundedVolumeListSceneQueryTo_p_Ogre__RegionSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RegionSceneQuery *)  ((Ogre::PlaneBoundedVolumeListSceneQuery *) x));
}
static void *_p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__RegionSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RegionSceneQuery *) (Ogre::SphereSceneQuery *) ((Ogre::DefaultSphereSceneQuery *) x));
}
static void *_p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__RegionSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RegionSceneQuery *) (Ogre::PlaneBoundedVolumeListSceneQuery *) ((Ogre::DefaultPlaneBoundedVolumeListSceneQuery *) x));
}
static void *_p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__RegionSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RegionSceneQuery *) (Ogre::AxisAlignedBoxSceneQuery *) ((Ogre::DefaultAxisAlignedBoxSceneQuery *) x));
}
static void *_p_Ogre__DefaultIntersectionSceneQueryTo_p_Ogre__IntersectionSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::IntersectionSceneQuery *)  ((Ogre::DefaultIntersectionSceneQuery *) x));
}
static void *_p_Ogre__DefaultRaySceneQueryTo_p_Ogre__RaySceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::RaySceneQuery *)  ((Ogre::DefaultRaySceneQuery *) x));
}
static void *_p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__SphereSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::SphereSceneQuery *)  ((Ogre::DefaultSphereSceneQuery *) x));
}
static void *_p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__PlaneBoundedVolumeListSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::PlaneBoundedVolumeListSceneQuery *)  ((Ogre::DefaultPlaneBoundedVolumeListSceneQuery *) x));
}
static void *_p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__AxisAlignedBoxSceneQuery(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::AxisAlignedBoxSceneQuery *)  ((Ogre::DefaultAxisAlignedBoxSceneQuery *) x));
}
static void *_p_Ogre__ResourceManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *)  ((Ogre::ResourceManager *) x));
}
static void *_p_Ogre__MaterialManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::MaterialManager *) x));
}
static void *_p_Ogre__TextureManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::TextureManager *) x));
}
static void *_p_Ogre__CompositorManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::CompositorManager *) x));
}
static void *_p_Ogre__FontManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::FontManager *) x));
}
static void *_p_Ogre__GpuProgramManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::GpuProgramManager *) x));
}
static void *_p_Ogre__HighLevelGpuProgramManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::HighLevelGpuProgramManager *) x));
}
static void *_p_Ogre__MeshManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::MeshManager *) x));
}
static void *_p_Ogre__OverlayManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *)  ((Ogre::OverlayManager *) x));
}
static void *_p_Ogre__ScriptCompilerManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *)  ((Ogre::ScriptCompilerManager *) x));
}
static void *_p_Ogre__ParticleSystemManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *)  ((Ogre::ParticleSystemManager *) x));
}
static void *_p_Ogre__SkeletonManagerTo_p_Ogre__ScriptLoader(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ScriptLoader *) (Ogre::ResourceManager *) ((Ogre::SkeletonManager *) x));
}
static void *_p_Ogre__PatchMeshTo_p_Ogre__Mesh(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::Mesh *)  ((Ogre::PatchMesh *) x));
}
static void *_p_Ogre__DefaultShadowCameraSetupTo_p_Ogre__ShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCameraSetup *)  ((Ogre::DefaultShadowCameraSetup *) x));
}
static void *_p_Ogre__FocusedShadowCameraSetupTo_p_Ogre__ShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCameraSetup *)  ((Ogre::FocusedShadowCameraSetup *) x));
}
static void *_p_Ogre__LiSPSMShadowCameraSetupTo_p_Ogre__ShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCameraSetup *) (Ogre::FocusedShadowCameraSetup *) ((Ogre::LiSPSMShadowCameraSetup *) x));
}
static void *_p_Ogre__PSSMShadowCameraSetupTo_p_Ogre__ShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCameraSetup *) (Ogre::FocusedShadowCameraSetup *)(Ogre::LiSPSMShadowCameraSetup *) ((Ogre::PSSMShadowCameraSetup *) x));
}
static void *_p_Ogre__PlaneOptimalShadowCameraSetupTo_p_Ogre__ShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::ShadowCameraSetup *)  ((Ogre::PlaneOptimalShadowCameraSetup *) x));
}
static void *_p_Ogre__LiSPSMShadowCameraSetupTo_p_Ogre__FocusedShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::FocusedShadowCameraSetup *)  ((Ogre::LiSPSMShadowCameraSetup *) x));
}
static void *_p_Ogre__PSSMShadowCameraSetupTo_p_Ogre__FocusedShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::FocusedShadowCameraSetup *) (Ogre::LiSPSMShadowCameraSetup *) ((Ogre::PSSMShadowCameraSetup *) x));
}
static void *_p_Ogre__PSSMShadowCameraSetupTo_p_Ogre__LiSPSMShadowCameraSetup(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::LiSPSMShadowCameraSetup *)  ((Ogre::PSSMShadowCameraSetup *) x));
}
static void *_p_Ogre__DefaultWorkQueueBaseTo_p_Ogre__WorkQueue(void *x, int *SWIGUNUSEDPARM(newmemory)) {
    return (void *)((Ogre::WorkQueue *)  ((Ogre::DefaultWorkQueueBase *) 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_AutoConstantEntry = {"_p_AutoConstantEntry", "AutoConstantEntry *", 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_FILE = {"_p_FILE", "FILE *", 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_GPUDeviceNameRule = {"_p_GPUDeviceNameRule", "GPUDeviceNameRule *", 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_GPUVendorRule = {"_p_GPUVendorRule", "GPUVendorRule *", 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_ImportData = {"_p_ImportData", "ImportData *", 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_Intp = {"_p_Intp", "Intp *", 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__AbstractNode = {"_p_Ogre__AbstractNode", "Ogre::AbstractNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AlignedMemory = {"_p_Ogre__AlignedMemory", "Ogre::AlignedMemory *", 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__Angle = {"_p_Ogre__Angle", "Ogre::Angle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimableObject = {"_p_Ogre__AnimableObject", "Ogre::AnimableObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimableValue = {"_p_Ogre__AnimableValue", "Ogre::AnimableValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Animation = {"_p_Ogre__Animation", "Ogre::Animation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimationContainer = {"_p_Ogre__AnimationContainer", "Ogre::AnimationContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimationControllerFunction = {"_p_Ogre__AnimationControllerFunction", "Ogre::AnimationControllerFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimationState = {"_p_Ogre__AnimationState", "Ogre::AnimationState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimationStateControllerValue = {"_p_Ogre__AnimationStateControllerValue", "Ogre::AnimationStateControllerValue *", 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__AnimationStateSet = {"_p_Ogre__AnimationStateSet", "Ogre::AnimationStateSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimationTrack = {"_p_Ogre__AnimationTrack", "Ogre::AnimationTrack *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnimationTrack__Listener = {"_p_Ogre__AnimationTrack__Listener", "Ogre::AnimationTrack::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Any = {"_p_Ogre__Any", "Ogre::Any *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnyNumeric = {"_p_Ogre__AnyNumeric", "Ogre::AnyNumeric *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AnyVALUE = {"_p_Ogre__AnyVALUE", "Ogre::AnyVALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Archive = {"_p_Ogre__Archive", "Ogre::Archive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ArchiveFactory = {"_p_Ogre__ArchiveFactory", "Ogre::ArchiveFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ArchiveManager = {"_p_Ogre__ArchiveManager", "Ogre::ArchiveManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AtomAbstractNode = {"_p_Ogre__AtomAbstractNode", "Ogre::AtomAbstractNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__AutoParamDataSource = {"_p_Ogre__AutoParamDataSource", "Ogre::AutoParamDataSource *", 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__AxisAlignedBoxSceneQuery = {"_p_Ogre__AxisAlignedBoxSceneQuery", "Ogre::AxisAlignedBoxSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BackgroundProcessResult = {"_p_Ogre__BackgroundProcessResult", "Ogre::BackgroundProcessResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BaseInstanceBatchVTF = {"_p_Ogre__BaseInstanceBatchVTF", "Ogre::BaseInstanceBatchVTF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Billboard = {"_p_Ogre__Billboard", "Ogre::Billboard *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BillboardChain = {"_p_Ogre__BillboardChain", "Ogre::BillboardChain *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BillboardChainFactory = {"_p_Ogre__BillboardChainFactory", "Ogre::BillboardChainFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BillboardChain__Element = {"_p_Ogre__BillboardChain__Element", "Ogre::BillboardChain::Element *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BillboardParticleRenderer = {"_p_Ogre__BillboardParticleRenderer", "Ogre::BillboardParticleRenderer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BillboardParticleRendererFactory = {"_p_Ogre__BillboardParticleRendererFactory", "Ogre::BillboardParticleRendererFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BillboardSet = {"_p_Ogre__BillboardSet", "Ogre::BillboardSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BillboardSetFactory = {"_p_Ogre__BillboardSetFactory", "Ogre::BillboardSetFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Bitwise = {"_p_Ogre__Bitwise", "Ogre::Bitwise *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Bone = {"_p_Ogre__Bone", "Ogre::Bone *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BorderPanelOverlayElement = {"_p_Ogre__BorderPanelOverlayElement", "Ogre::BorderPanelOverlayElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BorderPanelOverlayElementFactory = {"_p_Ogre__BorderPanelOverlayElementFactory", "Ogre::BorderPanelOverlayElementFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BorderRenderable = {"_p_Ogre__BorderRenderable", "Ogre::BorderRenderable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Box = {"_p_Ogre__Box", "Ogre::Box *|Ogre::Image::Box *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__BuiltinScriptTranslatorManager = {"_p_Ogre__BuiltinScriptTranslatorManager", "Ogre::BuiltinScriptTranslatorManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Camera = {"_p_Ogre__Camera", "Ogre::Camera *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Camera__Listener = {"_p_Ogre__Camera__Listener", "Ogre::Camera::Listener *", 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__Codec = {"_p_Ogre__Codec", "Ogre::Codec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ColourValue = {"_p_Ogre__ColourValue", "Ogre::ColourValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionPass = {"_p_Ogre__CompositionPass", "Ogre::CompositionPass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionPassTranslator = {"_p_Ogre__CompositionPassTranslator", "Ogre::CompositionPassTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionPass__InputTex = {"_p_Ogre__CompositionPass__InputTex", "Ogre::CompositionPass::InputTex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionTargetPass = {"_p_Ogre__CompositionTargetPass", "Ogre::CompositionTargetPass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionTargetPassTranslator = {"_p_Ogre__CompositionTargetPassTranslator", "Ogre::CompositionTargetPassTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionTechnique = {"_p_Ogre__CompositionTechnique", "Ogre::CompositionTechnique *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionTechniqueTranslator = {"_p_Ogre__CompositionTechniqueTranslator", "Ogre::CompositionTechniqueTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositionTechnique__TextureDefinition = {"_p_Ogre__CompositionTechnique__TextureDefinition", "Ogre::CompositionTechnique::TextureDefinition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Compositor = {"_p_Ogre__Compositor", "Ogre::Compositor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorChain = {"_p_Ogre__CompositorChain", "Ogre::CompositorChain *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorInstance = {"_p_Ogre__CompositorInstance", "Ogre::CompositorInstance *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorInstance__Listener = {"_p_Ogre__CompositorInstance__Listener", "Ogre::CompositorInstance::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorInstance__RenderSystemOperation = {"_p_Ogre__CompositorInstance__RenderSystemOperation", "Ogre::CompositorInstance::RenderSystemOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorInstance__TargetOperation = {"_p_Ogre__CompositorInstance__TargetOperation", "Ogre::CompositorInstance::TargetOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorLogic = {"_p_Ogre__CompositorLogic", "Ogre::CompositorLogic *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorManager = {"_p_Ogre__CompositorManager", "Ogre::CompositorManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorPtr = {"_p_Ogre__CompositorPtr", "Ogre::CompositorPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CompositorTranslator = {"_p_Ogre__CompositorTranslator", "Ogre::CompositorTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConcreteNode = {"_p_Ogre__ConcreteNode", "Ogre::ConcreteNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConfigFile = {"_p_Ogre__ConfigFile", "Ogre::ConfigFile *", 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__RenderQueueGroupMap_t = {"_p_Ogre__ConstMapIteratorT_Ogre__RenderQueueGroupMap_t", "Ogre::ConstMapIterator< Ogre::RenderQueue::RenderQueueGroupMap > *|Ogre::ConstMapIterator< Ogre::RenderQueueGroupMap > *|Ogre::RenderQueue::ConstQueueGroupIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Codec::CodecIterator *|Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::Codec *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::Codec * >,Ogre::GeneralAllocPolicy > >::type > *", 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__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::InstanceManager::InstanceBatchMapIterator *|Ogre::ConstMapIterator< Ogre::map< Ogre::String,Ogre::InstanceManager::InstanceBatchVec,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::InstanceManager::InstanceBatchVec >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstMapIteratorT_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_t = {"_p_Ogre__ConstMapIteratorT_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_t", "Ogre::SubMesh::AliasTextureIterator *|Ogre::ConstMapIterator< 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__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstMapIterator< Ogre::map< Ogre::uint32,TerrainSlot *,std::less< Ogre::uint32 >,Ogre::STLAllocator< std::pair< Ogre::uint32 const,TerrainSlot * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::TerrainGroup::ConstTerrainIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstMapIterator< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Pose::ConstVertexOffsetIterator *|Ogre::Pose::ConstNormalsIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstMapIterator< Ogre::map< unsigned short,Ogre::NodeAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::NodeAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Animation::NodeTrackIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstMapIterator< Ogre::map< unsigned short,Ogre::NumericAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::NumericAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Animation::NumericTrackIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstMapIterator< Ogre::map< unsigned short,Ogre::VertexAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::VertexAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Animation::VertexTrackIterator *", 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__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstVectorIterator< Ogre::vector< AutoConstantEntry,Ogre::STLAllocator< AutoConstantEntry,Ogre::GeneralAllocPolicy > >::type > *|Ogre::GpuProgramParameters::AutoConstantIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Technique::GPUDeviceNameRuleIterator *|Ogre::ConstVectorIterator< Ogre::vector< GPUDeviceNameRule,Ogre::STLAllocator< GPUDeviceNameRule,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstVectorIterator< Ogre::vector< GPUVendorRule,Ogre::STLAllocator< GPUVendorRule,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Technique::GPUVendorRuleIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstVectorIterator< Ogre::vector< Ogre::InstanceBatch *,Ogre::STLAllocator< Ogre::InstanceBatch *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::InstanceManager::InstanceBatchIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstVectorIterator< Ogre::vector< Ogre::LinkedSkeletonAnimationSource,Ogre::STLAllocator< Ogre::LinkedSkeletonAnimationSource,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Skeleton::LinkedSkeletonAnimSourceIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstVectorIterator< Ogre::vector< Ogre::Node *,Ogre::STLAllocator< Ogre::Node *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::RibbonTrail::NodeIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstVectorIterator< Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Material::LodValueIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Pass::ConstTextureUnitStateIterator *|Ogre::ConstVectorIterator< Ogre::vector< Ogre::TextureUnitState *,Ogre::STLAllocator< Ogre::TextureUnitState *,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConstVectorIterator< Ogre::vector< PoseRef,Ogre::STLAllocator< PoseRef,Ogre::GeneralAllocPolicy > >::type > *|Ogre::VertexPoseKeyFrame::ConstPoseRefIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ControllerManager = {"_p_Ogre__ControllerManager", "Ogre::ControllerManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ControllerT_float_t = {"_p_Ogre__ControllerT_float_t", "Ogre::Controller< float > *|Ogre::Controller< Ogre::Real > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ConvexBody = {"_p_Ogre__ConvexBody", "Ogre::ConvexBody *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CreateCompositorScriptCompilerEvent = {"_p_Ogre__CreateCompositorScriptCompilerEvent", "Ogre::CreateCompositorScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CreateGpuProgramScriptCompilerEvent = {"_p_Ogre__CreateGpuProgramScriptCompilerEvent", "Ogre::CreateGpuProgramScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CreateGpuSharedParametersScriptCompilerEvent = {"_p_Ogre__CreateGpuSharedParametersScriptCompilerEvent", "Ogre::CreateGpuSharedParametersScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent = {"_p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent", "Ogre::CreateHighLevelGpuProgramScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CreateMaterialScriptCompilerEvent = {"_p_Ogre__CreateMaterialScriptCompilerEvent", "Ogre::CreateMaterialScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CreateParticleSystemScriptCompilerEvent = {"_p_Ogre__CreateParticleSystemScriptCompilerEvent", "Ogre::CreateParticleSystemScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__CustomCompositionPass = {"_p_Ogre__CustomCompositionPass", "Ogre::CustomCompositionPass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DDSCodec = {"_p_Ogre__DDSCodec", "Ogre::DDSCodec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DataStream = {"_p_Ogre__DataStream", "Ogre::DataStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ZipDataStream = {"_p_Ogre__ZipDataStream", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_Ogre__DefaultAxisAlignedBoxSceneQuery = {"_p_Ogre__DefaultAxisAlignedBoxSceneQuery", "Ogre::DefaultAxisAlignedBoxSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultHardwareBufferManager = {"_p_Ogre__DefaultHardwareBufferManager", "Ogre::DefaultHardwareBufferManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultHardwareBufferManagerBase = {"_p_Ogre__DefaultHardwareBufferManagerBase", "Ogre::DefaultHardwareBufferManagerBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultHardwareIndexBuffer = {"_p_Ogre__DefaultHardwareIndexBuffer", "Ogre::DefaultHardwareIndexBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultHardwareVertexBuffer = {"_p_Ogre__DefaultHardwareVertexBuffer", "Ogre::DefaultHardwareVertexBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultIntersectionSceneQuery = {"_p_Ogre__DefaultIntersectionSceneQuery", "Ogre::DefaultIntersectionSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery = {"_p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery", "Ogre::DefaultPlaneBoundedVolumeListSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultRaySceneQuery = {"_p_Ogre__DefaultRaySceneQuery", "Ogre::DefaultRaySceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultSceneManager = {"_p_Ogre__DefaultSceneManager", "Ogre::DefaultSceneManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultSceneManagerFactory = {"_p_Ogre__DefaultSceneManagerFactory", "Ogre::DefaultSceneManagerFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultShadowCameraSetup = {"_p_Ogre__DefaultShadowCameraSetup", "Ogre::DefaultShadowCameraSetup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultSphereSceneQuery = {"_p_Ogre__DefaultSphereSceneQuery", "Ogre::DefaultSphereSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DefaultWorkQueueBase = {"_p_Ogre__DefaultWorkQueueBase", "Ogre::DefaultWorkQueueBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DeflateStream = {"_p_Ogre__DeflateStream", "Ogre::DeflateStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Degree = {"_p_Ogre__Degree", "Ogre::Degree *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DepthBuffer = {"_p_Ogre__DepthBuffer", "Ogre::DepthBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DistanceLodStrategy = {"_p_Ogre__DistanceLodStrategy", "Ogre::DistanceLodStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DriverVersion = {"_p_Ogre__DriverVersion", "Ogre::DriverVersion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DualQuaternion = {"_p_Ogre__DualQuaternion", "Ogre::DualQuaternion *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DynLib = {"_p_Ogre__DynLib", "Ogre::DynLib *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__DynLibManager = {"_p_Ogre__DynLibManager", "Ogre::DynLibManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EdgeData = {"_p_Ogre__EdgeData", "Ogre::EdgeData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EdgeData__Triangle = {"_p_Ogre__EdgeData__Triangle", "Ogre::EdgeData::Triangle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EdgeListBuilder = {"_p_Ogre__EdgeListBuilder", "Ogre::EdgeListBuilder *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmbeddedZipArchiveFactory = {"_p_Ogre__EmbeddedZipArchiveFactory", "Ogre::EmbeddedZipArchiveFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdAngle = {"_p_Ogre__EmitterCommands__CmdAngle", "Ogre::EmitterCommands::CmdAngle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdColour = {"_p_Ogre__EmitterCommands__CmdColour", "Ogre::EmitterCommands::CmdColour *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdColourRangeEnd = {"_p_Ogre__EmitterCommands__CmdColourRangeEnd", "Ogre::EmitterCommands::CmdColourRangeEnd *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdColourRangeStart = {"_p_Ogre__EmitterCommands__CmdColourRangeStart", "Ogre::EmitterCommands::CmdColourRangeStart *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdDirection = {"_p_Ogre__EmitterCommands__CmdDirection", "Ogre::EmitterCommands::CmdDirection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdDuration = {"_p_Ogre__EmitterCommands__CmdDuration", "Ogre::EmitterCommands::CmdDuration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdEmissionRate = {"_p_Ogre__EmitterCommands__CmdEmissionRate", "Ogre::EmitterCommands::CmdEmissionRate *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdEmittedEmitter = {"_p_Ogre__EmitterCommands__CmdEmittedEmitter", "Ogre::EmitterCommands::CmdEmittedEmitter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMaxDuration = {"_p_Ogre__EmitterCommands__CmdMaxDuration", "Ogre::EmitterCommands::CmdMaxDuration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMaxRepeatDelay = {"_p_Ogre__EmitterCommands__CmdMaxRepeatDelay", "Ogre::EmitterCommands::CmdMaxRepeatDelay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMaxTTL = {"_p_Ogre__EmitterCommands__CmdMaxTTL", "Ogre::EmitterCommands::CmdMaxTTL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMaxVelocity = {"_p_Ogre__EmitterCommands__CmdMaxVelocity", "Ogre::EmitterCommands::CmdMaxVelocity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMinDuration = {"_p_Ogre__EmitterCommands__CmdMinDuration", "Ogre::EmitterCommands::CmdMinDuration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMinRepeatDelay = {"_p_Ogre__EmitterCommands__CmdMinRepeatDelay", "Ogre::EmitterCommands::CmdMinRepeatDelay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMinTTL = {"_p_Ogre__EmitterCommands__CmdMinTTL", "Ogre::EmitterCommands::CmdMinTTL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdMinVelocity = {"_p_Ogre__EmitterCommands__CmdMinVelocity", "Ogre::EmitterCommands::CmdMinVelocity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdName = {"_p_Ogre__EmitterCommands__CmdName", "Ogre::EmitterCommands::CmdName *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdPosition = {"_p_Ogre__EmitterCommands__CmdPosition", "Ogre::EmitterCommands::CmdPosition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdRepeatDelay = {"_p_Ogre__EmitterCommands__CmdRepeatDelay", "Ogre::EmitterCommands::CmdRepeatDelay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdTTL = {"_p_Ogre__EmitterCommands__CmdTTL", "Ogre::EmitterCommands::CmdTTL *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdUp = {"_p_Ogre__EmitterCommands__CmdUp", "Ogre::EmitterCommands::CmdUp *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EmitterCommands__CmdVelocity = {"_p_Ogre__EmitterCommands__CmdVelocity", "Ogre::EmitterCommands::CmdVelocity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Entity = {"_p_Ogre__Entity", "Ogre::Entity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EntityFactory = {"_p_Ogre__EntityFactory", "Ogre::EntityFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EntityMaterialLodChangedEvent = {"_p_Ogre__EntityMaterialLodChangedEvent", "Ogre::EntityMaterialLodChangedEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__EntityMeshLodChangedEvent = {"_p_Ogre__EntityMeshLodChangedEvent", "Ogre::EntityMeshLodChangedEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Exception = {"_p_Ogre__Exception", "Ogre::Exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_DUPLICATE_ITEM > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_FILE_NOT_FOUND > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INTERNAL_ERROR > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALIDPARAMS > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_INVALID_STATE > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_ITEM_NOT_FOUND > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_NOT_IMPLEMENTED > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_RENDERINGAPI_ERROR > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t = {"_p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t", "Ogre::ExceptionCodeType< Ogre::Exception::ERR_RT_ASSERTION_FAILED > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExceptionFactory = {"_p_Ogre__ExceptionFactory", "Ogre::ExceptionFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExternalTextureSource = {"_p_Ogre__ExternalTextureSource", "Ogre::ExternalTextureSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ExternalTextureSourceManager = {"_p_Ogre__ExternalTextureSourceManager", "Ogre::ExternalTextureSourceManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FileHandleDataStream = {"_p_Ogre__FileHandleDataStream", "Ogre::FileHandleDataStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FileInfo = {"_p_Ogre__FileInfo", "Ogre::FileInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FileNotFoundException = {"_p_Ogre__FileNotFoundException", "Ogre::FileNotFoundException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FileStreamDataStream = {"_p_Ogre__FileStreamDataStream", "Ogre::FileStreamDataStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FileSystemArchive = {"_p_Ogre__FileSystemArchive", "Ogre::FileSystemArchive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FileSystemArchiveFactory = {"_p_Ogre__FileSystemArchiveFactory", "Ogre::FileSystemArchiveFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FloatGpuParameterControllerValue = {"_p_Ogre__FloatGpuParameterControllerValue", "Ogre::FloatGpuParameterControllerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FocusedShadowCameraSetup = {"_p_Ogre__FocusedShadowCameraSetup", "Ogre::FocusedShadowCameraSetup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Font = {"_p_Ogre__Font", "Ogre::Font *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FontManager = {"_p_Ogre__FontManager", "Ogre::FontManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FontPtr = {"_p_Ogre__FontPtr", "Ogre::FontPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Font__GlyphInfo = {"_p_Ogre__Font__GlyphInfo", "Ogre::Font::GlyphInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FrameEvent = {"_p_Ogre__FrameEvent", "Ogre::FrameEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FrameListener = {"_p_Ogre__FrameListener", "Ogre::FrameListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FrameTimeControllerValue = {"_p_Ogre__FrameTimeControllerValue", "Ogre::FrameTimeControllerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FreeImageCodec = {"_p_Ogre__FreeImageCodec", "Ogre::FreeImageCodec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Frustum = {"_p_Ogre__Frustum", "Ogre::Frustum *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__FrustumPlane = {"_p_Ogre__FrustumPlane", "enum Ogre::FrustumPlane *|Ogre::FrustumPlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuConstantDefinition = {"_p_Ogre__GpuConstantDefinition", "Ogre::GpuConstantDefinition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuLogicalBufferStruct = {"_p_Ogre__GpuLogicalBufferStruct", "Ogre::GpuLogicalBufferStruct *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuLogicalIndexUse = {"_p_Ogre__GpuLogicalIndexUse", "Ogre::GpuLogicalIndexUse *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuNamedConstants = {"_p_Ogre__GpuNamedConstants", "Ogre::GpuNamedConstants *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuNamedConstantsSerializer = {"_p_Ogre__GpuNamedConstantsSerializer", "Ogre::GpuNamedConstantsSerializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgram = {"_p_Ogre__GpuProgram", "Ogre::GpuProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgramManager = {"_p_Ogre__GpuProgramManager", "Ogre::GpuProgramManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgramParameters = {"_p_Ogre__GpuProgramParameters", "Ogre::GpuProgramParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgramParameters__AutoConstantDefinition = {"_p_Ogre__GpuProgramParameters__AutoConstantDefinition", "Ogre::GpuProgramParameters::AutoConstantDefinition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgramParameters__AutoConstantEntry = {"_p_Ogre__GpuProgramParameters__AutoConstantEntry", "Ogre::GpuProgramParameters::AutoConstantEntry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgramPtr = {"_p_Ogre__GpuProgramPtr", "Ogre::GpuProgramPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgramTranslator = {"_p_Ogre__GpuProgramTranslator", "Ogre::GpuProgramTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuProgramUsage = {"_p_Ogre__GpuProgramUsage", "Ogre::GpuProgramUsage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuSharedParameters = {"_p_Ogre__GpuSharedParameters", "Ogre::GpuSharedParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__GpuSharedParametersUsage = {"_p_Ogre__GpuSharedParametersUsage", "Ogre::GpuSharedParametersUsage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Grid2DPageStrategy = {"_p_Ogre__Grid2DPageStrategy", "Ogre::Grid2DPageStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Grid2DPageStrategyData = {"_p_Ogre__Grid2DPageStrategyData", "Ogre::Grid2DPageStrategyData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Grid3DPageStrategy = {"_p_Ogre__Grid3DPageStrategy", "Ogre::Grid3DPageStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Grid3DPageStrategyData = {"_p_Ogre__Grid3DPageStrategyData", "Ogre::Grid3DPageStrategyData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareBuffer = {"_p_Ogre__HardwareBuffer", "Ogre::HardwareBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareBufferLicensee = {"_p_Ogre__HardwareBufferLicensee", "Ogre::HardwareBufferLicensee *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareBufferManager = {"_p_Ogre__HardwareBufferManager", "Ogre::HardwareBufferManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareBufferManagerBase = {"_p_Ogre__HardwareBufferManagerBase", "Ogre::HardwareBufferManagerBase *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareIndexBuffer = {"_p_Ogre__HardwareIndexBuffer", "Ogre::HardwareIndexBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareIndexBufferSharedPtr = {"_p_Ogre__HardwareIndexBufferSharedPtr", "Ogre::HardwareIndexBufferSharedPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareOcclusionQuery = {"_p_Ogre__HardwareOcclusionQuery", "Ogre::HardwareOcclusionQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwarePixelBuffer = {"_p_Ogre__HardwarePixelBuffer", "Ogre::HardwarePixelBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwarePixelBufferSharedPtr = {"_p_Ogre__HardwarePixelBufferSharedPtr", "Ogre::HardwarePixelBufferSharedPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareVertexBuffer = {"_p_Ogre__HardwareVertexBuffer", "Ogre::HardwareVertexBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HardwareVertexBufferSharedPtr = {"_p_Ogre__HardwareVertexBufferSharedPtr", "Ogre::HardwareVertexBufferSharedPtr *", 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__HighLevelGpuProgram = {"_p_Ogre__HighLevelGpuProgram", "Ogre::HighLevelGpuProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HighLevelGpuProgramFactory = {"_p_Ogre__HighLevelGpuProgramFactory", "Ogre::HighLevelGpuProgramFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UnifiedHighLevelGpuProgramFactory = {"_p_Ogre__UnifiedHighLevelGpuProgramFactory", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_Ogre__HighLevelGpuProgramManager = {"_p_Ogre__HighLevelGpuProgramManager", "Ogre::HighLevelGpuProgramManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__HighLevelGpuProgramPtr = {"_p_Ogre__HighLevelGpuProgramPtr", "Ogre::HighLevelGpuProgramPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__IOException = {"_p_Ogre__IOException", "Ogre::IOException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__IlluminationPass = {"_p_Ogre__IlluminationPass", "Ogre::IlluminationPass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Image = {"_p_Ogre__Image", "Ogre::Image *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ImageCodec = {"_p_Ogre__ImageCodec", "Ogre::ImageCodec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ImportAbstractNode = {"_p_Ogre__ImportAbstractNode", "Ogre::ImportAbstractNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__IndexData = {"_p_Ogre__IndexData", "Ogre::IndexData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstanceBatch = {"_p_Ogre__InstanceBatch", "Ogre::InstanceBatch *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstanceBatchHW = {"_p_Ogre__InstanceBatchHW", "Ogre::InstanceBatchHW *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstanceBatchHW_VTF = {"_p_Ogre__InstanceBatchHW_VTF", "Ogre::InstanceBatchHW_VTF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstanceBatchShader = {"_p_Ogre__InstanceBatchShader", "Ogre::InstanceBatchShader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstanceBatchVTF = {"_p_Ogre__InstanceBatchVTF", "Ogre::InstanceBatchVTF *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstanceManager = {"_p_Ogre__InstanceManager", "Ogre::InstanceManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstancedEntity = {"_p_Ogre__InstancedEntity", "Ogre::InstancedEntity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstancedGeometry = {"_p_Ogre__InstancedGeometry", "Ogre::InstancedGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InstancedGeometry__BatchInstanceIterator = {"_p_Ogre__InstancedGeometry__BatchInstanceIterator", "Ogre::InstancedGeometry::BatchInstanceIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InternalErrorException = {"_p_Ogre__InternalErrorException", "Ogre::InternalErrorException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__IntersectionSceneQuery = {"_p_Ogre__IntersectionSceneQuery", "Ogre::IntersectionSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__IntersectionSceneQueryListener = {"_p_Ogre__IntersectionSceneQueryListener", "Ogre::IntersectionSceneQueryListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__IntersectionSceneQueryResult = {"_p_Ogre__IntersectionSceneQueryResult", "Ogre::IntersectionSceneQueryResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InvalidParametersException = {"_p_Ogre__InvalidParametersException", "Ogre::InvalidParametersException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__InvalidStateException = {"_p_Ogre__InvalidStateException", "Ogre::InvalidStateException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ItemIdentityException = {"_p_Ogre__ItemIdentityException", "Ogre::ItemIdentityException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__KeyFrame = {"_p_Ogre__KeyFrame", "Ogre::KeyFrame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LayerBlendModeEx = {"_p_Ogre__LayerBlendModeEx", "Ogre::LayerBlendModeEx *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LiSPSMShadowCameraSetup = {"_p_Ogre__LiSPSMShadowCameraSetup", "Ogre::LiSPSMShadowCameraSetup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Light = {"_p_Ogre__Light", "Ogre::Light *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LightFactory = {"_p_Ogre__LightFactory", "Ogre::LightFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LinkedSkeletonAnimationSource = {"_p_Ogre__LinkedSkeletonAnimationSource", "Ogre::LinkedSkeletonAnimationSource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LodListener = {"_p_Ogre__LodListener", "Ogre::LodListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LodStrategy = {"_p_Ogre__LodStrategy", "Ogre::LodStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LodStrategyManager = {"_p_Ogre__LodStrategyManager", "Ogre::LodStrategyManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Log = {"_p_Ogre__Log", "Ogre::Log *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LogListener = {"_p_Ogre__LogListener", "Ogre::LogListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__LogManager = {"_p_Ogre__LogManager", "Ogre::LogManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Log__Stream = {"_p_Ogre__Log__Stream", "Ogre::Log::Stream *", 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__ManualObjectFactory = {"_p_Ogre__ManualObjectFactory", "Ogre::ManualObjectFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ManualObject__ManualObjectSection = {"_p_Ogre__ManualObject__ManualObjectSection", "Ogre::ManualObject::ManualObjectSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ManualResourceLoader = {"_p_Ogre__ManualResourceLoader", "Ogre::ManualResourceLoader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t = {"_p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t", "Ogre::MapIterator< Ogre::RenderQueue::RenderQueueGroupMap > *|Ogre::RenderQueue::QueueGroupIterator *|Ogre::MapIterator< Ogre::RenderQueueGroupMap > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ArchiveManager::ArchiveMapIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::Archive *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::Archive * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConfigFile::SectionIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ConfigFile::SettingsMultiMap *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ConfigFile::SettingsMultiMap * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::MovableObject *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::MovableObject * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Entity::ChildObjectListIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::OverlayContainer::ChildContainerIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::OverlayContainer *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::OverlayContainer * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::OverlayContainer::ChildIterator *|Ogre::OverlayManager::TemplateIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::OverlayElement *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::OverlayElement * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::OverlayManager::OverlayMapIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::Overlay *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::Overlay * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ParticleSystemManager::ParticleAffectorFactoryIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleAffectorFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleAffectorFactory * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ParticleSystemManager::ParticleEmitterFactoryIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleEmitterFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleEmitterFactory * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ParticleSystemManager::ParticleRendererFactoryIterator *|Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleSystemRendererFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleSystemRendererFactory * >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::ParticleSystem *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::ParticleSystem * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::ParticleSystemManager::ParticleSystemTemplateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_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_t = {"_p_Ogre__MapIteratorT_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_t", "Ogre::MapIterator< Ogre::map< Ogre::String,Ogre::RenderTarget *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::RenderTarget * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::RenderSystem::RenderTargetIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::MapIterator< Ogre::map< Ogre::uint32,Ogre::Region *,std::less< Ogre::uint32 >,Ogre::STLAllocator< std::pair< Ogre::uint32 const,Ogre::Region * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::StaticGeometry::RegionIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::MapIterator< Ogre::map< Ogre::uint32,TerrainSlot *,std::less< Ogre::uint32 >,Ogre::STLAllocator< std::pair< Ogre::uint32 const,TerrainSlot * >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::TerrainGroup::TerrainIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Pose::VertexOffsetIterator *|Ogre::Pose::NormalsIterator *|Ogre::MapIterator< Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ConfigFile::SettingsIterator *|Ogre::MapIterator< Ogre::multimap< 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__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::MapIterator< Ogre::multimap< size_t,Ogre::VertexBoneAssignment,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::VertexBoneAssignment >,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Mesh::BoneAssignmentIterator *|Ogre::SubMesh::BoneAssignmentIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Material = {"_p_Ogre__Material", "Ogre::Material *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialManager = {"_p_Ogre__MaterialManager", "Ogre::MaterialManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialManager__Listener = {"_p_Ogre__MaterialManager__Listener", "Ogre::MaterialManager::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialPtr = {"_p_Ogre__MaterialPtr", "Ogre::MaterialPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialScriptContext = {"_p_Ogre__MaterialScriptContext", "Ogre::MaterialScriptContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialScriptProgramDefinition = {"_p_Ogre__MaterialScriptProgramDefinition", "Ogre::MaterialScriptProgramDefinition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialSerializer = {"_p_Ogre__MaterialSerializer", "Ogre::MaterialSerializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialSerializer__Listener = {"_p_Ogre__MaterialSerializer__Listener", "Ogre::MaterialSerializer::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MaterialTranslator = {"_p_Ogre__MaterialTranslator", "Ogre::MaterialTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Math = {"_p_Ogre__Math", "Ogre::Math *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Matrix3 = {"_p_Ogre__Matrix3", "Ogre::Matrix3 *", 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__MemoryDataStream = {"_p_Ogre__MemoryDataStream", "Ogre::MemoryDataStream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Mesh = {"_p_Ogre__Mesh", "Ogre::Mesh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MeshLodUsage = {"_p_Ogre__MeshLodUsage", "Ogre::MeshLodUsage *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MeshManager = {"_p_Ogre__MeshManager", "Ogre::MeshManager *", 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__MeshSerializer = {"_p_Ogre__MeshSerializer", "Ogre::MeshSerializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MeshSerializerListener = {"_p_Ogre__MeshSerializerListener", "Ogre::MeshSerializerListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MovableObject = {"_p_Ogre__MovableObject", "Ogre::MovableObject *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MovableObjectFactory = {"_p_Ogre__MovableObjectFactory", "Ogre::MovableObjectFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MovableObjectLodChangedEvent = {"_p_Ogre__MovableObjectLodChangedEvent", "Ogre::MovableObjectLodChangedEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MovableObject__Listener = {"_p_Ogre__MovableObject__Listener", "Ogre::MovableObject::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MovablePlane = {"_p_Ogre__MovablePlane", "Ogre::MovablePlane *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__MultiRenderTarget = {"_p_Ogre__MultiRenderTarget", "Ogre::MultiRenderTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__NameGenerator = {"_p_Ogre__NameGenerator", "Ogre::NameGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__NedPoolingImpl = {"_p_Ogre__NedPoolingImpl", "Ogre::NedPoolingImpl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__NedPoolingPolicy = {"_p_Ogre__NedPoolingPolicy", "Ogre::NedPoolingPolicy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Node = {"_p_Ogre__Node", "Ogre::Node *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__NodeAnimationTrack = {"_p_Ogre__NodeAnimationTrack", "Ogre::NodeAnimationTrack *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Node__DebugRenderable = {"_p_Ogre__Node__DebugRenderable", "Ogre::Node::DebugRenderable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Node__Listener = {"_p_Ogre__Node__Listener", "Ogre::Node::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__NumericAnimationTrack = {"_p_Ogre__NumericAnimationTrack", "Ogre::NumericAnimationTrack *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__NumericKeyFrame = {"_p_Ogre__NumericKeyFrame", "Ogre::NumericKeyFrame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ObjectAbstractNode = {"_p_Ogre__ObjectAbstractNode", "Ogre::ObjectAbstractNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OptimisedUtil = {"_p_Ogre__OptimisedUtil", "Ogre::OptimisedUtil *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Overlay = {"_p_Ogre__Overlay", "Ogre::Overlay *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayContainer = {"_p_Ogre__OverlayContainer", "Ogre::OverlayContainer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElement = {"_p_Ogre__OverlayElement", "Ogre::OverlayElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdCaption = {"_p_Ogre__OverlayElementCommands__CmdCaption", "Ogre::OverlayElementCommands::CmdCaption *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdHeight = {"_p_Ogre__OverlayElementCommands__CmdHeight", "Ogre::OverlayElementCommands::CmdHeight *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdHorizontalAlign = {"_p_Ogre__OverlayElementCommands__CmdHorizontalAlign", "Ogre::OverlayElementCommands::CmdHorizontalAlign *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdLeft = {"_p_Ogre__OverlayElementCommands__CmdLeft", "Ogre::OverlayElementCommands::CmdLeft *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdMaterial = {"_p_Ogre__OverlayElementCommands__CmdMaterial", "Ogre::OverlayElementCommands::CmdMaterial *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdMetricsMode = {"_p_Ogre__OverlayElementCommands__CmdMetricsMode", "Ogre::OverlayElementCommands::CmdMetricsMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdTop = {"_p_Ogre__OverlayElementCommands__CmdTop", "Ogre::OverlayElementCommands::CmdTop *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdVerticalAlign = {"_p_Ogre__OverlayElementCommands__CmdVerticalAlign", "Ogre::OverlayElementCommands::CmdVerticalAlign *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdVisible = {"_p_Ogre__OverlayElementCommands__CmdVisible", "Ogre::OverlayElementCommands::CmdVisible *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementCommands__CmdWidth = {"_p_Ogre__OverlayElementCommands__CmdWidth", "Ogre::OverlayElementCommands::CmdWidth *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayElementFactory = {"_p_Ogre__OverlayElementFactory", "Ogre::OverlayElementFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__OverlayManager = {"_p_Ogre__OverlayManager", "Ogre::OverlayManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PSSMShadowCameraSetup = {"_p_Ogre__PSSMShadowCameraSetup", "Ogre::PSSMShadowCameraSetup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Page = {"_p_Ogre__Page", "Ogre::Page *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageContent = {"_p_Ogre__PageContent", "Ogre::PageContent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageContentCollection = {"_p_Ogre__PageContentCollection", "Ogre::PageContentCollection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageContentCollectionFactory = {"_p_Ogre__PageContentCollectionFactory", "Ogre::PageContentCollectionFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageContentFactory = {"_p_Ogre__PageContentFactory", "Ogre::PageContentFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageManager = {"_p_Ogre__PageManager", "Ogre::PageManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageProvider = {"_p_Ogre__PageProvider", "Ogre::PageProvider *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageStrategy = {"_p_Ogre__PageStrategy", "Ogre::PageStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PageStrategyData = {"_p_Ogre__PageStrategyData", "Ogre::PageStrategyData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PagedWorld = {"_p_Ogre__PagedWorld", "Ogre::PagedWorld *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PagedWorldSection = {"_p_Ogre__PagedWorldSection", "Ogre::PagedWorldSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PagedWorldSectionFactory = {"_p_Ogre__PagedWorldSectionFactory", "Ogre::PagedWorldSectionFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PanelOverlayElement = {"_p_Ogre__PanelOverlayElement", "Ogre::PanelOverlayElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PanelOverlayElementFactory = {"_p_Ogre__PanelOverlayElementFactory", "Ogre::PanelOverlayElementFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParamCommand = {"_p_Ogre__ParamCommand", "Ogre::ParamCommand *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParamDictionary = {"_p_Ogre__ParamDictionary", "Ogre::ParamDictionary *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParameterDef = {"_p_Ogre__ParameterDef", "Ogre::ParameterDef *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Particle = {"_p_Ogre__Particle", "Ogre::Particle *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleAffector = {"_p_Ogre__ParticleAffector", "Ogre::ParticleAffector *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleAffectorFactory = {"_p_Ogre__ParticleAffectorFactory", "Ogre::ParticleAffectorFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleAffectorTranslator = {"_p_Ogre__ParticleAffectorTranslator", "Ogre::ParticleAffectorTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleEmitter = {"_p_Ogre__ParticleEmitter", "Ogre::ParticleEmitter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleEmitterFactory = {"_p_Ogre__ParticleEmitterFactory", "Ogre::ParticleEmitterFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleEmitterTranslator = {"_p_Ogre__ParticleEmitterTranslator", "Ogre::ParticleEmitterTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleIterator = {"_p_Ogre__ParticleIterator", "Ogre::ParticleIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleSystem = {"_p_Ogre__ParticleSystem", "Ogre::ParticleSystem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleSystemFactory = {"_p_Ogre__ParticleSystemFactory", "Ogre::ParticleSystemFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleSystemManager = {"_p_Ogre__ParticleSystemManager", "Ogre::ParticleSystemManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleSystemRenderer = {"_p_Ogre__ParticleSystemRenderer", "Ogre::ParticleSystemRenderer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleSystemRendererFactory = {"_p_Ogre__ParticleSystemRendererFactory", "Ogre::ParticleSystemRendererFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleSystemTranslator = {"_p_Ogre__ParticleSystemTranslator", "Ogre::ParticleSystemTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ParticleVisualData = {"_p_Ogre__ParticleVisualData", "Ogre::ParticleVisualData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Pass = {"_p_Ogre__Pass", "Ogre::Pass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PassTranslator = {"_p_Ogre__PassTranslator", "Ogre::PassTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Pass__HashFunc = {"_p_Ogre__Pass__HashFunc", "Ogre::Pass::HashFunc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PassthroughControllerFunction = {"_p_Ogre__PassthroughControllerFunction", "Ogre::PassthroughControllerFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PatchMesh = {"_p_Ogre__PatchMesh", "Ogre::PatchMesh *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PatchMeshPtr = {"_p_Ogre__PatchMeshPtr", "Ogre::PatchMeshPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PatchSurface = {"_p_Ogre__PatchSurface", "Ogre::PatchSurface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PixelBox = {"_p_Ogre__PixelBox", "Ogre::PixelBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PixelCountLodStrategy = {"_p_Ogre__PixelCountLodStrategy", "Ogre::PixelCountLodStrategy *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PixelUtil = {"_p_Ogre__PixelUtil", "Ogre::PixelUtil *", 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__PlaneBoundedVolume = {"_p_Ogre__PlaneBoundedVolume", "Ogre::PlaneBoundedVolume *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PlaneBoundedVolumeListSceneQuery = {"_p_Ogre__PlaneBoundedVolumeListSceneQuery", "Ogre::PlaneBoundedVolumeListSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PlaneOptimalShadowCameraSetup = {"_p_Ogre__PlaneOptimalShadowCameraSetup", "Ogre::PlaneOptimalShadowCameraSetup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PlatformInformation = {"_p_Ogre__PlatformInformation", "Ogre::PlatformInformation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Plugin = {"_p_Ogre__Plugin", "Ogre::Plugin *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Polygon = {"_p_Ogre__Polygon", "Ogre::Polygon *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Pose = {"_p_Ogre__Pose", "Ogre::Pose *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PreApplyTextureAliasesScriptCompilerEvent = {"_p_Ogre__PreApplyTextureAliasesScriptCompilerEvent", "Ogre::PreApplyTextureAliasesScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PrefabFactory = {"_p_Ogre__PrefabFactory", "Ogre::PrefabFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ProcessNameExclusionScriptCompilerEvent = {"_p_Ogre__ProcessNameExclusionScriptCompilerEvent", "Ogre::ProcessNameExclusionScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ProcessResourceNameScriptCompilerEvent = {"_p_Ogre__ProcessResourceNameScriptCompilerEvent", "Ogre::ProcessResourceNameScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Profile = {"_p_Ogre__Profile", "Ogre::Profile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Profiler = {"_p_Ogre__Profiler", "Ogre::Profiler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__PropertyAbstractNode = {"_p_Ogre__PropertyAbstractNode", "Ogre::PropertyAbstractNode *", 0, 0, (void*)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__QueuedRenderableCollection = {"_p_Ogre__QueuedRenderableCollection", "Ogre::QueuedRenderableCollection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__QueuedRenderableVisitor = {"_p_Ogre__QueuedRenderableVisitor", "Ogre::QueuedRenderableVisitor *", 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__Ray = {"_p_Ogre__Ray", "Ogre::Ray *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RaySceneQuery = {"_p_Ogre__RaySceneQuery", "Ogre::RaySceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RaySceneQueryListener = {"_p_Ogre__RaySceneQueryListener", "Ogre::RaySceneQueryListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RaySceneQueryResultEntry = {"_p_Ogre__RaySceneQueryResultEntry", "Ogre::RaySceneQueryResultEntry *", 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__Rectangle2D = {"_p_Ogre__Rectangle2D", "Ogre::Rectangle2D *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RegionSceneQuery = {"_p_Ogre__RegionSceneQuery", "Ogre::RegionSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderObjectListener = {"_p_Ogre__RenderObjectListener", "Ogre::RenderObjectListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderOperation = {"_p_Ogre__RenderOperation", "Ogre::RenderOperation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderPriorityGroup = {"_p_Ogre__RenderPriorityGroup", "Ogre::RenderPriorityGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueue = {"_p_Ogre__RenderQueue", "Ogre::RenderQueue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueueGroup = {"_p_Ogre__RenderQueueGroup", "Ogre::RenderQueueGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueueGroup__ConstPriorityMapIterator = {"_p_Ogre__RenderQueueGroup__ConstPriorityMapIterator", "Ogre::RenderQueueGroup::ConstPriorityMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueueGroup__PriorityMapIterator = {"_p_Ogre__RenderQueueGroup__PriorityMapIterator", "Ogre::RenderQueueGroup::PriorityMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueueInvocation = {"_p_Ogre__RenderQueueInvocation", "Ogre::RenderQueueInvocation *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueueInvocationSequence = {"_p_Ogre__RenderQueueInvocationSequence", "Ogre::RenderQueueInvocationSequence *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueueListener = {"_p_Ogre__RenderQueueListener", "Ogre::RenderQueueListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderQueue__RenderableListener = {"_p_Ogre__RenderQueue__RenderableListener", "Ogre::RenderQueue::RenderableListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderSystem = {"_p_Ogre__RenderSystem", "Ogre::RenderSystem *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderSystemCapabilities = {"_p_Ogre__RenderSystemCapabilities", "Ogre::RenderSystemCapabilities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderSystemCapabilitiesManager = {"_p_Ogre__RenderSystemCapabilitiesManager", "Ogre::RenderSystemCapabilitiesManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderSystemCapabilitiesSerializer = {"_p_Ogre__RenderSystemCapabilitiesSerializer", "Ogre::RenderSystemCapabilitiesSerializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderSystem__Listener = {"_p_Ogre__RenderSystem__Listener", "Ogre::RenderSystem::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderSystem__RenderSystemContext = {"_p_Ogre__RenderSystem__RenderSystemContext", "Ogre::RenderSystem::RenderSystemContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderTarget = {"_p_Ogre__RenderTarget", "Ogre::RenderTarget *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderTargetEvent = {"_p_Ogre__RenderTargetEvent", "Ogre::RenderTargetEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderTargetListener = {"_p_Ogre__RenderTargetListener", "Ogre::RenderTargetListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderTargetViewportEvent = {"_p_Ogre__RenderTargetViewportEvent", "Ogre::RenderTargetViewportEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderTarget__FrameStats = {"_p_Ogre__RenderTarget__FrameStats", "Ogre::RenderTarget::FrameStats *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderTarget__Impl = {"_p_Ogre__RenderTarget__Impl", "Ogre::RenderTarget::Impl *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderTexture = {"_p_Ogre__RenderTexture", "Ogre::RenderTexture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderToVertexBuffer = {"_p_Ogre__RenderToVertexBuffer", "Ogre::RenderToVertexBuffer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderWindow = {"_p_Ogre__RenderWindow", "Ogre::RenderWindow *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderWindowDescription = {"_p_Ogre__RenderWindowDescription", "Ogre::RenderWindowDescription *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Renderable = {"_p_Ogre__Renderable", "Ogre::Renderable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderablePass = {"_p_Ogre__RenderablePass", "Ogre::RenderablePass *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Renderable__RenderSystemData = {"_p_Ogre__Renderable__RenderSystemData", "Ogre::Renderable::RenderSystemData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Renderable__Visitor = {"_p_Ogre__Renderable__Visitor", "Ogre::Renderable::Visitor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RenderingAPIException = {"_p_Ogre__RenderingAPIException", "Ogre::RenderingAPIException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Resource = {"_p_Ogre__Resource", "Ogre::Resource *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceBackgroundQueue = {"_p_Ogre__ResourceBackgroundQueue", "Ogre::ResourceBackgroundQueue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceBackgroundQueue__Listener = {"_p_Ogre__ResourceBackgroundQueue__Listener", "Ogre::ResourceBackgroundQueue::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceGroupListener = {"_p_Ogre__ResourceGroupListener", "Ogre::ResourceGroupListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceGroupManager = {"_p_Ogre__ResourceGroupManager", "Ogre::ResourceGroupManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceGroupManager__ResourceManagerIterator = {"_p_Ogre__ResourceGroupManager__ResourceManagerIterator", "Ogre::ResourceGroupManager::ResourceManagerIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceLoadingListener = {"_p_Ogre__ResourceLoadingListener", "Ogre::ResourceLoadingListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceManager = {"_p_Ogre__ResourceManager", "Ogre::ResourceManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceManager__ResourceMapIterator = {"_p_Ogre__ResourceManager__ResourceMapIterator", "Ogre::ResourceManager::ResourceMapIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ResourceManager__ResourcePool = {"_p_Ogre__ResourceManager__ResourcePool", "Ogre::ResourceManager::ResourcePool *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Resource__Listener = {"_p_Ogre__Resource__Listener", "Ogre::Resource::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RibbonTrail = {"_p_Ogre__RibbonTrail", "Ogre::RibbonTrail *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RibbonTrailFactory = {"_p_Ogre__RibbonTrailFactory", "Ogre::RibbonTrailFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Root = {"_p_Ogre__Root", "Ogre::Root *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Root__MovableObjectFactoryIterator = {"_p_Ogre__Root__MovableObjectFactoryIterator", "Ogre::Root::MovableObjectFactoryIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RotationalSpline = {"_p_Ogre__RotationalSpline", "Ogre::RotationalSpline *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__RuntimeAssertionException = {"_p_Ogre__RuntimeAssertionException", "Ogre::RuntimeAssertionException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScaleControllerFunction = {"_p_Ogre__ScaleControllerFunction", "Ogre::ScaleControllerFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager = {"_p_Ogre__SceneManager", "Ogre::SceneManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManagerEnumerator = {"_p_Ogre__SceneManagerEnumerator", "Ogre::SceneManagerEnumerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManagerEnumerator__MetaDataIterator = {"_p_Ogre__SceneManagerEnumerator__MetaDataIterator", "Ogre::SceneManagerEnumerator::MetaDataIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManagerEnumerator__SceneManagerIterator = {"_p_Ogre__SceneManagerEnumerator__SceneManagerIterator", "Ogre::SceneManagerEnumerator::SceneManagerIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManagerFactory = {"_p_Ogre__SceneManagerFactory", "Ogre::SceneManagerFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManagerMetaData = {"_p_Ogre__SceneManagerMetaData", "Ogre::SceneManagerMetaData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__AnimationIterator = {"_p_Ogre__SceneManager__AnimationIterator", "Ogre::SceneManager::AnimationIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__CameraIterator = {"_p_Ogre__SceneManager__CameraIterator", "Ogre::SceneManager::CameraIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__Listener = {"_p_Ogre__SceneManager__Listener", "Ogre::SceneManager::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__MovableObjectIterator = {"_p_Ogre__SceneManager__MovableObjectIterator", "Ogre::SceneManager::MovableObjectIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__RenderContext = {"_p_Ogre__SceneManager__RenderContext", "Ogre::SceneManager::RenderContext *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor = {"_p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor", "Ogre::SceneManager::SceneMgrQueuedRenderableVisitor *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__SkyBoxGenParameters = {"_p_Ogre__SceneManager__SkyBoxGenParameters", "Ogre::SceneManager::SkyBoxGenParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__SkyDomeGenParameters = {"_p_Ogre__SceneManager__SkyDomeGenParameters", "Ogre::SceneManager::SkyDomeGenParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneManager__SkyPlaneGenParameters = {"_p_Ogre__SceneManager__SkyPlaneGenParameters", "Ogre::SceneManager::SkyPlaneGenParameters *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneNode = {"_p_Ogre__SceneNode", "Ogre::SceneNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneQuery = {"_p_Ogre__SceneQuery", "Ogre::SceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneQueryListener = {"_p_Ogre__SceneQueryListener", "Ogre::SceneQueryListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneQueryResult = {"_p_Ogre__SceneQueryResult", "Ogre::SceneQueryResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SceneQuery__WorldFragment = {"_p_Ogre__SceneQuery__WorldFragment", "Ogre::SceneQuery::WorldFragment *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptCompiler = {"_p_Ogre__ScriptCompiler", "Ogre::ScriptCompiler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptCompilerEvent = {"_p_Ogre__ScriptCompilerEvent", "Ogre::ScriptCompilerEvent *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptCompilerListener = {"_p_Ogre__ScriptCompilerListener", "Ogre::ScriptCompilerListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptCompilerManager = {"_p_Ogre__ScriptCompilerManager", "Ogre::ScriptCompilerManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptLexer = {"_p_Ogre__ScriptLexer", "Ogre::ScriptLexer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptLoader = {"_p_Ogre__ScriptLoader", "Ogre::ScriptLoader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptParser = {"_p_Ogre__ScriptParser", "Ogre::ScriptParser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptToken = {"_p_Ogre__ScriptToken", "Ogre::ScriptToken *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptTranslator = {"_p_Ogre__ScriptTranslator", "Ogre::ScriptTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ScriptTranslatorManager = {"_p_Ogre__ScriptTranslatorManager", "Ogre::ScriptTranslatorManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Serializer = {"_p_Ogre__Serializer", "Ogre::Serializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ShadowCameraSetup = {"_p_Ogre__ShadowCameraSetup", "Ogre::ShadowCameraSetup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ShadowCaster = {"_p_Ogre__ShadowCaster", "Ogre::ShadowCaster *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ShadowRenderable = {"_p_Ogre__ShadowRenderable", "Ogre::ShadowRenderable *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ShadowTextureConfig = {"_p_Ogre__ShadowTextureConfig", "Ogre::ShadowTextureConfig *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ShadowTextureManager = {"_p_Ogre__ShadowTextureManager", "Ogre::ShadowTextureManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ShadowVolumeExtrudeProgram = {"_p_Ogre__ShadowVolumeExtrudeProgram", "Ogre::ShadowVolumeExtrudeProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedParamsTranslator = {"_p_Ogre__SharedParamsTranslator", "Ogre::SharedParamsTranslator *", 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__CodecData_t = {"_p_Ogre__SharedPtrT_Ogre__CodecData_t", "Ogre::Codec::CodecDataPtr *|Ogre::SharedPtr< Ogre::Codec::CodecData > *|Ogre::SharedPtr< Ogre::CodecData > *", 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__Material_t = {"_p_Ogre__SharedPtrT_Ogre__Material_t", "Ogre::SharedPtr< Ogre::Material > *", 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::GpuProgramManager::Microcode *|Ogre::MemoryDataStreamPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SharedPtrT_Ogre__Mesh_t = {"_p_Ogre__SharedPtrT_Ogre__Mesh_t", "Ogre::SharedPtr< Ogre::Mesh > *", 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__SimplePageContentCollection = {"_p_Ogre__SimplePageContentCollection", "Ogre::SimplePageContentCollection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SimplePageContentCollectionFactory = {"_p_Ogre__SimplePageContentCollectionFactory", "Ogre::SimplePageContentCollectionFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SimpleRenderable = {"_p_Ogre__SimpleRenderable", "Ogre::SimpleRenderable *", 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__Skeleton = {"_p_Ogre__Skeleton", "Ogre::Skeleton *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SkeletonInstance = {"_p_Ogre__SkeletonInstance", "Ogre::SkeletonInstance *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SkeletonManager = {"_p_Ogre__SkeletonManager", "Ogre::SkeletonManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SkeletonPtr = {"_p_Ogre__SkeletonPtr", "Ogre::SkeletonPtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SkeletonSerializer = {"_p_Ogre__SkeletonSerializer", "Ogre::SkeletonSerializer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Sphere = {"_p_Ogre__Sphere", "Ogre::Sphere *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SphereSceneQuery = {"_p_Ogre__SphereSceneQuery", "Ogre::SphereSceneQuery *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StaticFaceGroup = {"_p_Ogre__StaticFaceGroup", "Ogre::StaticFaceGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StaticGeometry = {"_p_Ogre__StaticGeometry", "Ogre::StaticGeometry *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StaticPluginLoader = {"_p_Ogre__StaticPluginLoader", "Ogre::StaticPluginLoader *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StreamSerialiser = {"_p_Ogre__StreamSerialiser", "Ogre::StreamSerialiser *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StreamSerialiser__Chunk = {"_p_Ogre__StreamSerialiser__Chunk", "Ogre::StreamSerialiser::Chunk *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StringConverter = {"_p_Ogre__StringConverter", "Ogre::StringConverter *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StringInterface = {"_p_Ogre__StringInterface", "Ogre::StringInterface *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__StringUtil = {"_p_Ogre__StringUtil", "Ogre::StringUtil *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SubEntity = {"_p_Ogre__SubEntity", "Ogre::SubEntity *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__SubMesh = {"_p_Ogre__SubMesh", "Ogre::SubMesh *", 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 *|Ogre::Font::UVRect *", 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__TagPoint = {"_p_Ogre__TagPoint", "Ogre::TagPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TangentSpaceCalc = {"_p_Ogre__TangentSpaceCalc", "Ogre::TangentSpaceCalc *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TangentSpaceCalc__Result = {"_p_Ogre__TangentSpaceCalc__Result", "Ogre::TangentSpaceCalc::Result *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Technique = {"_p_Ogre__Technique", "Ogre::Technique *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TechniqueTranslator = {"_p_Ogre__TechniqueTranslator", "Ogre::TechniqueTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TempBlendedBufferInfo = {"_p_Ogre__TempBlendedBufferInfo", "Ogre::TempBlendedBufferInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Terrain = {"_p_Ogre__Terrain", "Ogre::Terrain *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainGlobalOptions = {"_p_Ogre__TerrainGlobalOptions", "Ogre::TerrainGlobalOptions *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainGroup = {"_p_Ogre__TerrainGroup", "Ogre::TerrainGroup *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainGroup__RayResult = {"_p_Ogre__TerrainGroup__RayResult", "Ogre::TerrainGroup::RayResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainGroup__TerrainSlotDefinition = {"_p_Ogre__TerrainGroup__TerrainSlotDefinition", "Ogre::TerrainGroup::TerrainSlotDefinition *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainLayerBlendMap = {"_p_Ogre__TerrainLayerBlendMap", "Ogre::TerrainLayerBlendMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainLayerDeclaration = {"_p_Ogre__TerrainLayerDeclaration", "Ogre::TerrainLayerDeclaration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainLayerSampler = {"_p_Ogre__TerrainLayerSampler", "Ogre::TerrainLayerSampler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainLayerSamplerElement = {"_p_Ogre__TerrainLayerSamplerElement", "Ogre::TerrainLayerSamplerElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainMaterialGenerator = {"_p_Ogre__TerrainMaterialGenerator", "Ogre::TerrainMaterialGenerator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainMaterialGeneratorA = {"_p_Ogre__TerrainMaterialGeneratorA", "Ogre::TerrainMaterialGeneratorA *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainMaterialGenerator__Profile = {"_p_Ogre__TerrainMaterialGenerator__Profile", "Ogre::TerrainMaterialGenerator::Profile *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainPagedWorldSection = {"_p_Ogre__TerrainPagedWorldSection", "Ogre::TerrainPagedWorldSection *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainPaging = {"_p_Ogre__TerrainPaging", "Ogre::TerrainPaging *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainQuadTreeNode = {"_p_Ogre__TerrainQuadTreeNode", "Ogre::TerrainQuadTreeNode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TerrainQuadTreeNode__LodLevel = {"_p_Ogre__TerrainQuadTreeNode__LodLevel", "Ogre::TerrainQuadTreeNode::LodLevel *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Terrain__GpuBufferAllocator = {"_p_Ogre__Terrain__GpuBufferAllocator", "Ogre::Terrain::GpuBufferAllocator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Terrain__ImportData = {"_p_Ogre__Terrain__ImportData", "Ogre::Terrain::ImportData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TexCoordModifierControllerValue = {"_p_Ogre__TexCoordModifierControllerValue", "Ogre::TexCoordModifierControllerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextAreaOverlayElement = {"_p_Ogre__TextAreaOverlayElement", "Ogre::TextAreaOverlayElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextAreaOverlayElementFactory = {"_p_Ogre__TextAreaOverlayElementFactory", "Ogre::TextAreaOverlayElementFactory *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Texture = {"_p_Ogre__Texture", "Ogre::Texture *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextureFrameControllerValue = {"_p_Ogre__TextureFrameControllerValue", "Ogre::TextureFrameControllerValue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextureManager = {"_p_Ogre__TextureManager", "Ogre::TextureManager *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TexturePtr = {"_p_Ogre__TexturePtr", "Ogre::TexturePtr *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextureSourceTranslator = {"_p_Ogre__TextureSourceTranslator", "Ogre::TextureSourceTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextureUnitState = {"_p_Ogre__TextureUnitState", "Ogre::TextureUnitState *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextureUnitState__TextureEffect = {"_p_Ogre__TextureUnitState__TextureEffect", "Ogre::TextureUnitState::TextureEffect *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextureUnitState__UVWAddressingMode = {"_p_Ogre__TextureUnitState__UVWAddressingMode", "Ogre::TextureUnitState::UVWAddressingMode *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TextureUnitTranslator = {"_p_Ogre__TextureUnitTranslator", "Ogre::TextureUnitTranslator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TimeIndex = {"_p_Ogre__TimeIndex", "Ogre::TimeIndex *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Timer = {"_p_Ogre__Timer", "Ogre::Timer *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__TransformKeyFrame = {"_p_Ogre__TransformKeyFrame", "Ogre::TransformKeyFrame *", 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__UTFString___const_fwd_iterator = {"_p_Ogre__UTFString___const_fwd_iterator", "Ogre::UTFString::_const_fwd_iterator *|Ogre::UTFString::const_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UTFString___const_rev_iterator = {"_p_Ogre__UTFString___const_rev_iterator", "Ogre::UTFString::_const_rev_iterator *|Ogre::UTFString::const_reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UTFString___fwd_iterator = {"_p_Ogre__UTFString___fwd_iterator", "Ogre::UTFString::_fwd_iterator *|Ogre::UTFString::iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UTFString___rev_iterator = {"_p_Ogre__UTFString___rev_iterator", "Ogre::UTFString::_rev_iterator *|Ogre::UTFString::reverse_iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UnifiedHighLevelGpuProgram = {"_p_Ogre__UnifiedHighLevelGpuProgram", "Ogre::UnifiedHighLevelGpuProgram *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UnimplementedException = {"_p_Ogre__UnimplementedException", "Ogre::UnimplementedException *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__UserObjectBindings = {"_p_Ogre__UserObjectBindings", "Ogre::UserObjectBindings *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VariableAccessAbstractNode = {"_p_Ogre__VariableAccessAbstractNode", "Ogre::VariableAccessAbstractNode *", 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__Vector4 = {"_p_Ogre__Vector4", "Ogre::Vector4 *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Overlay::Overlay2DElementsIterator *|Ogre::VectorIterator< Ogre::list< Ogre::OverlayContainer *,Ogre::STLAllocator< Ogre::OverlayContainer *,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Skeleton::BoneIterator *|Ogre::VectorIterator< Ogre::vector< Ogre::Bone *,Ogre::STLAllocator< Ogre::Bone *,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::CompositionPass *,Ogre::STLAllocator< Ogre::CompositionPass *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::CompositionTargetPass::PassIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::CompositionTargetPass *,Ogre::STLAllocator< Ogre::CompositionTargetPass *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::CompositionTechnique::TargetPassIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::CompositionTechnique *,Ogre::STLAllocator< Ogre::CompositionTechnique *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Compositor::TechniqueIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::CompositorInstance *,Ogre::STLAllocator< Ogre::CompositorInstance *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::CompositorChain::InstanceIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Technique::IlluminationPassIterator *|Ogre::VectorIterator< Ogre::vector< Ogre::IlluminationPass *,Ogre::STLAllocator< Ogre::IlluminationPass *,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::Pass *,Ogre::STLAllocator< Ogre::Pass *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Technique::PassIterator *", 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__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::ShadowCaster::ShadowRenderableListIterator *|Ogre::VectorIterator< Ogre::vector< Ogre::ShadowRenderable *,Ogre::STLAllocator< Ogre::ShadowRenderable *,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::Mesh::SubMeshIterator *|Ogre::VectorIterator< Ogre::vector< Ogre::SubMesh *,Ogre::STLAllocator< Ogre::SubMesh *,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::Technique *,Ogre::STLAllocator< Ogre::Technique *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Material::TechniqueIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::CompositionTechnique::TextureDefinitionIterator *|Ogre::VectorIterator< Ogre::vector< Ogre::TextureDefinition *,Ogre::STLAllocator< Ogre::TextureDefinition *,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VectorIterator< Ogre::vector< Ogre::TextureUnitState *,Ogre::STLAllocator< Ogre::TextureUnitState *,Ogre::GeneralAllocPolicy > >::type > *|Ogre::Pass::TextureUnitStateIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t = {"_p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t", "Ogre::VertexPoseKeyFrame::PoseRefIterator *|Ogre::VectorIterator< Ogre::vector< PoseRef,Ogre::STLAllocator< PoseRef,Ogre::GeneralAllocPolicy > >::type > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexAnimationTrack = {"_p_Ogre__VertexAnimationTrack", "Ogre::VertexAnimationTrack *", 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__VertexBufferBinding = {"_p_Ogre__VertexBufferBinding", "Ogre::VertexBufferBinding *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexCacheProfiler = {"_p_Ogre__VertexCacheProfiler", "Ogre::VertexCacheProfiler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexData = {"_p_Ogre__VertexData", "Ogre::VertexData *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexDeclaration = {"_p_Ogre__VertexDeclaration", "Ogre::VertexDeclaration *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexElement = {"_p_Ogre__VertexElement", "Ogre::VertexElement *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexMorphKeyFrame = {"_p_Ogre__VertexMorphKeyFrame", "Ogre::VertexMorphKeyFrame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VertexPoseKeyFrame = {"_p_Ogre__VertexPoseKeyFrame", "Ogre::VertexPoseKeyFrame *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ViewPoint = {"_p_Ogre__ViewPoint", "Ogre::ViewPoint *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Viewport = {"_p_Ogre__Viewport", "Ogre::Viewport *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__Viewport__Listener = {"_p_Ogre__Viewport__Listener", "Ogre::Viewport::Listener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__VisibleObjectsBoundsInfo = {"_p_Ogre__VisibleObjectsBoundsInfo", "Ogre::VisibleObjectsBoundsInfo *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WaveformControllerFunction = {"_p_Ogre__WaveformControllerFunction", "Ogre::WaveformControllerFunction *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WindowEventListener = {"_p_Ogre__WindowEventListener", "Ogre::WindowEventListener *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WindowEventUtilities = {"_p_Ogre__WindowEventUtilities", "Ogre::WindowEventUtilities *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WireBoundingBox = {"_p_Ogre__WireBoundingBox", "Ogre::WireBoundingBox *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WorkQueue = {"_p_Ogre__WorkQueue", "Ogre::WorkQueue *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WorkQueue__Request = {"_p_Ogre__WorkQueue__Request", "Ogre::WorkQueue::Request *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WorkQueue__RequestHandler = {"_p_Ogre__WorkQueue__RequestHandler", "Ogre::WorkQueue::RequestHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WorkQueue__Response = {"_p_Ogre__WorkQueue__Response", "Ogre::WorkQueue::Response *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__WorkQueue__ResponseHandler = {"_p_Ogre__WorkQueue__ResponseHandler", "Ogre::WorkQueue::ResponseHandler *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ZipArchive = {"_p_Ogre__ZipArchive", "Ogre::ZipArchive *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__ZipArchiveFactory = {"_p_Ogre__ZipArchiveFactory", "Ogre::ZipArchiveFactory *", 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__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::Particle *,Ogre::STLAllocator< Ogre::Particle *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::Plane,Ogre::STLAllocator< Ogre::Plane,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::list< Ogre::ResourceLocation *,Ogre::STLAllocator< Ogre::ResourceLocation *,Ogre::GeneralAllocPolicy > >::type *|Ogre::ResourceGroupManager::LocationList *", 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__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_Ogre__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::VertexDeclaration::VertexElementList *|Ogre::list< Ogre::VertexElement,Ogre::STLAllocator< Ogre::VertexElement,Ogre::GeneralAllocPolicy > >::type *", 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__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::ResourceGroupManager::ResourceDeclarationList *|Ogre::list< ResourceDeclaration,Ogre::STLAllocator< ResourceDeclaration,Ogre::GeneralAllocPolicy > >::type *", 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__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::GpuProgramManager::SharedParametersMap *|Ogre::map< Ogre::String,Ogre::GpuSharedParametersPtr,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::GpuSharedParametersPtr >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::OverlayElementFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::OverlayElementFactory * >,Ogre::GeneralAllocPolicy > >::type *|Ogre::OverlayManager::FactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::PageContentCollectionFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::PageContentCollectionFactory * >,Ogre::GeneralAllocPolicy > >::type *|Ogre::PageManager::ContentCollectionFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::PageContentFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::PageContentFactory * >,Ogre::GeneralAllocPolicy > >::type *|Ogre::PageManager::ContentFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::PageManager::StrategyMap *|Ogre::map< Ogre::String,Ogre::PageStrategy *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::PageStrategy * >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::PagedWorldSectionFactory *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::PagedWorldSectionFactory * >,Ogre::GeneralAllocPolicy > >::type *|Ogre::PageManager::WorldSectionFactoryMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::PagedWorld::SectionMap *|Ogre::map< Ogre::String,Ogre::PagedWorldSection *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::PagedWorldSection * >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::PageManager::WorldMap *|Ogre::map< Ogre::String,Ogre::PagedWorld *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::PagedWorld * >,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__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__String_Ogre__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< Ogre::String,Ogre::RenderSystemCapabilities *,std::less< Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String const,Ogre::RenderSystemCapabilities * >,Ogre::GeneralAllocPolicy > >::type *", 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_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::VertexBufferBinding::BindingIndexMap *|Ogre::map< Ogre::ushort,Ogre::ushort,std::less< Ogre::ushort >,Ogre::STLAllocator< std::pair< Ogre::ushort const,Ogre::ushort >,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__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< size_t,Ogre::Vector3,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type *|Ogre::Pose::NormalsMap *|Ogre::Pose::VertexOffsetMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::VertexBufferBinding::VertexBufferBindingMap *|Ogre::map< unsigned short,Ogre::HardwareVertexBufferSharedPtr,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::HardwareVertexBufferSharedPtr >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::Animation::NodeTrackList *|Ogre::map< unsigned short,Ogre::NodeAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::NodeAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::map< unsigned short,Ogre::NumericAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::NumericAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type *|Ogre::Animation::NumericTrackList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::Animation::VertexTrackList *|Ogre::map< unsigned short,Ogre::VertexAnimationTrack *,std::less< unsigned short >,Ogre::STLAllocator< std::pair< unsigned short const,Ogre::VertexAnimationTrack * >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::WindowEventUtilities::WindowEventListeners *|Ogre::multimap< Ogre::RenderWindow *,Ogre::WindowEventListener *,std::less< Ogre::RenderWindow * >,Ogre::STLAllocator< std::pair< Ogre::RenderWindow *const,Ogre::WindowEventListener * >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::multimap< Ogre::TextureUnitState::TextureEffectType,Ogre::TextureEffect,std::less< Ogre::TextureUnitState::TextureEffectType >,Ogre::STLAllocator< std::pair< Ogre::TextureUnitState::TextureEffectType const,Ogre::TextureEffect >,Ogre::GeneralAllocPolicy > >::type *|Ogre::TextureUnitState::EffectMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::multimap< Ogre::Vector3,Ogre::Vector3,std::less< Ogre::Vector3 >,Ogre::STLAllocator< std::pair< Ogre::Vector3 const,Ogre::Vector3 >,Ogre::GeneralAllocPolicy > >::type *|Ogre::Polygon::EdgeMap *", 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__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::Mesh::VertexBoneAssignmentList *|Ogre::SubMesh::VertexBoneAssignmentList *|Ogre::multimap< size_t,Ogre::VertexBoneAssignment,std::less< size_t >,Ogre::STLAllocator< std::pair< size_t const,Ogre::VertexBoneAssignment >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::set< Ogre::Entity *,std::less< Ogre::Entity * >,Ogre::STLAllocator< Ogre::Entity *,Ogre::GeneralAllocPolicy > >::type *|Ogre::Entity::EntitySet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::set< Ogre::Pass *,std::less< Ogre::Pass * >,Ogre::STLAllocator< Ogre::Pass *,Ogre::GeneralAllocPolicy > >::type *|Ogre::Pass::PassSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::set< Ogre::SceneQuery::WorldFragmentType,std::less< Ogre::SceneQuery::WorldFragmentType >,Ogre::STLAllocator< Ogre::SceneQuery::WorldFragmentType,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::RenderSystemCapabilities::ShaderProfiles *|Ogre::GpuProgramManager::SyntaxCodes *|Ogre::set< Ogre::String,std::less< Ogre::String >,Ogre::STLAllocator< Ogre::String,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::set< Ogre::Texture *,std::less< Ogre::Texture * >,Ogre::STLAllocator< Ogre::Texture *,Ogre::GeneralAllocPolicy > >::type *|Ogre::CompositorManager::UniqueTextureSet *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::set< Ogre::ushort,std::less< Ogre::ushort >,Ogre::STLAllocator< Ogre::ushort,Ogre::GeneralAllocPolicy > >::type *|Ogre::Animation::TrackHandleList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::GpuProgramParameters::AutoConstantList *|Ogre::vector< AutoConstantEntry,Ogre::STLAllocator< AutoConstantEntry,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::Terrain::LayerInstanceList *|Ogre::vector< LayerInstance,Ogre::STLAllocator< LayerInstance,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::Camera *,Ogre::STLAllocator< Ogre::Camera *,Ogre::GeneralAllocPolicy > >::type *|Ogre::PageManager::CameraList *", 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__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::EdgeData::EdgeGroupList *|Ogre::vector< Ogre::EdgeGroup,Ogre::STLAllocator< Ogre::EdgeGroup,Ogre::GeneralAllocPolicy > >::type *", 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__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::Font::CodePointRangeList *|Ogre::vector< Ogre::Font::CodePointRange,Ogre::STLAllocator< Ogre::Font::CodePointRange,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::GpuProgramParameters::GpuSharedParamUsageList *|Ogre::vector< Ogre::GpuSharedParametersUsage,Ogre::STLAllocator< Ogre::GpuSharedParametersUsage,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::HardwareAnimationData,Ogre::STLAllocator< Ogre::HardwareAnimationData,Ogre::GeneralAllocPolicy > >::type *|Ogre::VertexData::HardwareAnimationDataList *", 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__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::SubMesh::LODFaceList *|Ogre::vector< Ogre::IndexData *,Ogre::STLAllocator< Ogre::IndexData *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::InstancedEntity *,Ogre::STLAllocator< Ogre::InstancedEntity *,Ogre::GeneralAllocPolicy > >::type *|Ogre::InstanceBatch::InstancedEntityVec *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::MeshLodUsage,Ogre::STLAllocator< Ogre::MeshLodUsage,Ogre::GeneralAllocPolicy > >::type *|Ogre::Mesh::MeshLodUsageList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::Page::ContentCollectionList *|Ogre::vector< Ogre::PageContentCollection *,Ogre::STLAllocator< Ogre::PageContentCollection *,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::PageContent *,Ogre::STLAllocator< Ogre::PageContent *,Ogre::GeneralAllocPolicy > >::type *|Ogre::SimplePageContentCollection::ContentList *", 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::PlaneBoundedVolume::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__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::Plugin *,Ogre::STLAllocator< Ogre::Plugin *,Ogre::GeneralAllocPolicy > >::type *|Ogre::Root::PluginInstanceList *", 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__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::TerrainMaterialGenerator::ProfileList *|Ogre::vector< Ogre::Profile *,Ogre::STLAllocator< Ogre::Profile *,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__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::PSSMShadowCameraSetup::SplitPointList *|Ogre::Material::LodValueList *|Ogre::Mesh::LodValueList *|Ogre::vector< Ogre::Real,Ogre::STLAllocator< Ogre::Real,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::RenderOperation *,Ogre::STLAllocator< Ogre::RenderOperation *,Ogre::GeneralAllocPolicy > >::type *|Ogre::InstancedGeometry::RenderOperationVector *", 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__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::RenderTexture *,Ogre::STLAllocator< Ogre::RenderTexture *,Ogre::GeneralAllocPolicy > >::type *|Ogre::MultiRenderTarget::BoundSufaceList *", 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 *|Ogre::WindowEventUtilities::Windows *", 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__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::TargetOperation,Ogre::STLAllocator< Ogre::TargetOperation,Ogre::GeneralAllocPolicy > >::type *|Ogre::CompositorInstance::CompiledState *", 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__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::TerrainGroup::TerrainList *|Ogre::vector< Ogre::Terrain *,Ogre::STLAllocator< Ogre::Terrain *,Ogre::GeneralAllocPolicy > >::type *", 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_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::Triangle,Ogre::STLAllocator< Ogre::Triangle,Ogre::GeneralAllocPolicy > >::type *|Ogre::EdgeData::TriangleList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::Vector3,Ogre::STLAllocator< Ogre::Vector3,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::Vector4,Ogre::STLAllocator< Ogre::Vector4,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< Ogre::ushort,Ogre::STLAllocator< Ogre::ushort,Ogre::GeneralAllocPolicy > >::type *|Ogre::Skeleton::BoneHandleMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< PoseRef,Ogre::STLAllocator< PoseRef,Ogre::GeneralAllocPolicy > >::type *|Ogre::VertexPoseKeyFrame::PoseRefList *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::EdgeData::TriangleLightFacingList *|Ogre::vector< char,Ogre::STLAllocator< char,Ogre::GeneralAllocPolicy > >::type *", 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 *|Ogre::AnimationState::BoneBlendMask *", 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_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::vector< std::pair< Ogre::String,Ogre::String >,Ogre::STLAllocator< std::pair< Ogre::String,Ogre::String >,Ogre::GeneralAllocPolicy > >::type *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type = {"_p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type", "Ogre::Mesh::IndexMap *|Ogre::SubMesh::IndexMap *|Ogre::vector< unsigned short,Ogre::STLAllocator< unsigned short,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_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_ResourcePool = {"_p_ResourcePool", "ResourcePool *", 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_a_3__float = {"_p_a_3__float", "float (*)[3]|Ogre::Real (*)[3]", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_bool = {"_p_bool", "bool *", 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_double = {"_p_double", "double *", 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_f_size_t_p_void_size_t__bool = {"_p_f_size_t_p_void_size_t__bool", "bool (*)(size_t,void *,size_t)|Ogre::EmbeddedZipArchiveFactory::DecryptEmbeddedZipFileFunc", 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_iterator = {"_p_iterator", "iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_long = {"_p_long", "long *", 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_p_Ogre__KeyFrame = {"_p_p_Ogre__KeyFrame", "Ogre::KeyFrame **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Ogre__NumericKeyFrame = {"_p_p_Ogre__NumericKeyFrame", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Ogre__TransformKeyFrame = {"_p_p_Ogre__TransformKeyFrame", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Ogre__VertexMorphKeyFrame = {"_p_p_Ogre__VertexMorphKeyFrame", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Ogre__VertexPoseKeyFrame = {"_p_p_Ogre__VertexPoseKeyFrame", 0, 0, 0, 0, 0};
static swig_type_info _swigt__p_p_Ogre__LinkedSkeletonAnimationSource = {"_p_p_Ogre__LinkedSkeletonAnimationSource", "Ogre::LinkedSkeletonAnimationSource **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Ogre__Matrix4 = {"_p_p_Ogre__Matrix4", "Ogre::Matrix4 **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_Ogre__Terrain = {"_p_p_Ogre__Terrain", "Ogre::Terrain **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_float = {"_p_p_float", "float **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_unsigned_char = {"_p_p_unsigned_char", "unsigned char **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_unsigned_int = {"_p_p_unsigned_int", "Ogre::RGBA **|unsigned int **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_unsigned_short = {"_p_p_unsigned_short", "unsigned short **", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_p_void = {"_p_p_void", "void **", 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_t = {"_p_size_t", "size_t *", 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_stringT_unsigned_int_t = {"_p_std__basic_stringT_unsigned_int_t", "Ogre::UTFString::utf32string *|std::basic_string< unsigned int > *", 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::StringUtil::StrStreamType *|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__exception = {"_p_std__exception", "std::exception *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__fstream = {"_p_std__fstream", "std::fstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ifstream = {"_p_std__ifstream", "std::ifstream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ios__fmtflags = {"_p_std__ios__fmtflags", "std::ios::fmtflags *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__ostream = {"_p_std__ostream", "std::ostream *", 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__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t = {"_p_std__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t", "std::pair< Ogre::SharedPtr< Ogre::MemoryDataStream >,Ogre::SharedPtr< Ogre::Codec::CodecData > > *|std::pair< Ogre::SharedPtr< Ogre::MemoryDataStream >,Ogre::SharedPtr< Ogre::CodecData > > *|Ogre::Codec::DecodeResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t = {"_p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t", "std::pair< Ogre::SharedPtr< Ogre::Resource >,bool > *|Ogre::ResourceManager::ResourceCreateOrRetrieveResult *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_bool_Ogre__Vector3_t = {"_p_std__pairT_bool_Ogre__Vector3_t", "std::pair< bool,Ogre::Vector3 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_bool_float_t = {"_p_std__pairT_bool_float_t", "std::pair< bool,float > *|std::pair< bool,Ogre::Real > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_bool_std__string_t = {"_p_std__pairT_bool_std__string_t", "std::pair< bool,std::string > *|std::pair< bool,Ogre::String > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_size_t_size_t_t = {"_p_std__pairT_size_t_size_t_t", "std::pair< size_t,size_t > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_unsigned_char_unsigned_char_t = {"_p_std__pairT_unsigned_char_unsigned_char_t", "std::pair< unsigned char,unsigned char > *|std::pair< Ogre::uint8,Ogre::uint8 > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__pairT_unsigned_int_unsigned_int_t = {"_p_std__pairT_unsigned_int_unsigned_int_t", "Ogre::Font::CodePointRange *|std::pair< unsigned int,unsigned int > *", 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__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t = {"_p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t", "::std::tr1::unordered_map< Ogre::String,Ogre::ushort > *|Ogre::Mesh::SubMeshNameMap *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__type_info = {"_p_std__type_info", "std::type_info *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t = {"_p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t", "Ogre::EdgeData::TriangleFaceNormalList *|std::vector< Ogre::Vector4,STLAllocator< Ogre::Vector4,Ogre::CategorisedAlignAllocPolicy< Ogre::MEMCATEGORY_GEOMETRY > > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t = {"_p_std__vectorT_std__string_std__allocatorT_std__string_t_t", "std::vector< std::string,std::allocator< std::string > > *|std::vector< Ogre::String,std::allocator< Ogre::String > > *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__wostream = {"_p_std__wostream", "std::wostream *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_std__wstring = {"_p_std__wstring", "std::wstring *", 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_swig__ConstIterator = {"_p_swig__ConstIterator", "swig::ConstIterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__GC_VALUE = {"_p_swig__GC_VALUE", "swig::GC_VALUE *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_swig__Iterator = {"_p_swig__Iterator", "swig::Iterator *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_time_t = {"_p_time_t", "time_t *", 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::UTFString::unicode_char *|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::UTFString::code_point *|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_void = {"_p_void", "VALUE|void *", 0, 0, (void*)0, 0};
static swig_type_info _swigt__p_wchar_t = {"_p_wchar_t", "wchar_t *", 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_AutoConstantEntry,
  &_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_FILE,
  &_swigt__p_FactoryMap,
  &_swigt__p_GPUDeviceNameRule,
  &_swigt__p_GPUDeviceNameRuleIterator,
  &_swigt__p_GPUDeviceNameRuleList,
  &_swigt__p_GPUVendorRule,
  &_swigt__p_GPUVendorRuleIterator,
  &_swigt__p_GPUVendorRuleList,
  &_swigt__p_GpuSharedParamUsageList,
  &_swigt__p_HardwareAnimationDataList,
  &_swigt__p_IdMap,
  &_swigt__p_IlluminationPassIterator,
  &_swigt__p_ImportData,
  &_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__AbstractNode,
  &_swigt__p_Ogre__AlignedMemory,
  &_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__Angle,
  &_swigt__p_Ogre__AnimableObject,
  &_swigt__p_Ogre__AnimableValue,
  &_swigt__p_Ogre__Animation,
  &_swigt__p_Ogre__AnimationContainer,
  &_swigt__p_Ogre__AnimationControllerFunction,
  &_swigt__p_Ogre__AnimationState,
  &_swigt__p_Ogre__AnimationStateControllerValue,
  &_swigt__p_Ogre__AnimationStateIterator,
  &_swigt__p_Ogre__AnimationStateSet,
  &_swigt__p_Ogre__AnimationTrack,
  &_swigt__p_Ogre__AnimationTrack__Listener,
  &_swigt__p_Ogre__Any,
  &_swigt__p_Ogre__AnyNumeric,
  &_swigt__p_Ogre__AnyVALUE,
  &_swigt__p_Ogre__Archive,
  &_swigt__p_Ogre__ArchiveFactory,
  &_swigt__p_Ogre__ArchiveManager,
  &_swigt__p_Ogre__AtomAbstractNode,
  &_swigt__p_Ogre__AutoParamDataSource,
  &_swigt__p_Ogre__AxisAlignedBox,
  &_swigt__p_Ogre__AxisAlignedBoxSceneQuery,
  &_swigt__p_Ogre__BackgroundProcessResult,
  &_swigt__p_Ogre__BaseInstanceBatchVTF,
  &_swigt__p_Ogre__Billboard,
  &_swigt__p_Ogre__BillboardChain,
  &_swigt__p_Ogre__BillboardChainFactory,
  &_swigt__p_Ogre__BillboardChain__Element,
  &_swigt__p_Ogre__BillboardParticleRenderer,
  &_swigt__p_Ogre__BillboardParticleRendererFactory,
  &_swigt__p_Ogre__BillboardSet,
  &_swigt__p_Ogre__BillboardSetFactory,
  &_swigt__p_Ogre__Bitwise,
  &_swigt__p_Ogre__Bone,
  &_swigt__p_Ogre__BorderPanelOverlayElement,
  &_swigt__p_Ogre__BorderPanelOverlayElementFactory,
  &_swigt__p_Ogre__BorderRenderable,
  &_swigt__p_Ogre__Box,
  &_swigt__p_Ogre__BuiltinScriptTranslatorManager,
  &_swigt__p_Ogre__Camera,
  &_swigt__p_Ogre__Camera__Listener,
  &_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__Codec,
  &_swigt__p_Ogre__ColourValue,
  &_swigt__p_Ogre__CompositionPass,
  &_swigt__p_Ogre__CompositionPassTranslator,
  &_swigt__p_Ogre__CompositionPass__InputTex,
  &_swigt__p_Ogre__CompositionTargetPass,
  &_swigt__p_Ogre__CompositionTargetPassTranslator,
  &_swigt__p_Ogre__CompositionTechnique,
  &_swigt__p_Ogre__CompositionTechniqueTranslator,
  &_swigt__p_Ogre__CompositionTechnique__TextureDefinition,
  &_swigt__p_Ogre__Compositor,
  &_swigt__p_Ogre__CompositorChain,
  &_swigt__p_Ogre__CompositorInstance,
  &_swigt__p_Ogre__CompositorInstance__Listener,
  &_swigt__p_Ogre__CompositorInstance__RenderSystemOperation,
  &_swigt__p_Ogre__CompositorInstance__TargetOperation,
  &_swigt__p_Ogre__CompositorLogic,
  &_swigt__p_Ogre__CompositorManager,
  &_swigt__p_Ogre__CompositorPtr,
  &_swigt__p_Ogre__CompositorTranslator,
  &_swigt__p_Ogre__ConcreteNode,
  &_swigt__p_Ogre__ConfigFile,
  &_swigt__p_Ogre__ConstAnimationStateIterator,
  &_swigt__p_Ogre__ConstEnabledAnimationStateIterator,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__RenderQueueGroupMap_t,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_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,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstMapIteratorT_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_t,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstShadowTextureConfigIterator,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__ControllerManager,
  &_swigt__p_Ogre__ControllerT_float_t,
  &_swigt__p_Ogre__ConvexBody,
  &_swigt__p_Ogre__CreateCompositorScriptCompilerEvent,
  &_swigt__p_Ogre__CreateGpuProgramScriptCompilerEvent,
  &_swigt__p_Ogre__CreateGpuSharedParametersScriptCompilerEvent,
  &_swigt__p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent,
  &_swigt__p_Ogre__CreateMaterialScriptCompilerEvent,
  &_swigt__p_Ogre__CreateParticleSystemScriptCompilerEvent,
  &_swigt__p_Ogre__CustomCompositionPass,
  &_swigt__p_Ogre__DDSCodec,
  &_swigt__p_Ogre__DataStream,
  &_swigt__p_Ogre__DefaultAxisAlignedBoxSceneQuery,
  &_swigt__p_Ogre__DefaultHardwareBufferManager,
  &_swigt__p_Ogre__DefaultHardwareBufferManagerBase,
  &_swigt__p_Ogre__DefaultHardwareIndexBuffer,
  &_swigt__p_Ogre__DefaultHardwareVertexBuffer,
  &_swigt__p_Ogre__DefaultIntersectionSceneQuery,
  &_swigt__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery,
  &_swigt__p_Ogre__DefaultRaySceneQuery,
  &_swigt__p_Ogre__DefaultSceneManager,
  &_swigt__p_Ogre__DefaultSceneManagerFactory,
  &_swigt__p_Ogre__DefaultShadowCameraSetup,
  &_swigt__p_Ogre__DefaultSphereSceneQuery,
  &_swigt__p_Ogre__DefaultWorkQueueBase,
  &_swigt__p_Ogre__DeflateStream,
  &_swigt__p_Ogre__Degree,
  &_swigt__p_Ogre__DepthBuffer,
  &_swigt__p_Ogre__DistanceLodStrategy,
  &_swigt__p_Ogre__DriverVersion,
  &_swigt__p_Ogre__DualQuaternion,
  &_swigt__p_Ogre__DynLib,
  &_swigt__p_Ogre__DynLibManager,
  &_swigt__p_Ogre__EdgeData,
  &_swigt__p_Ogre__EdgeData__Triangle,
  &_swigt__p_Ogre__EdgeListBuilder,
  &_swigt__p_Ogre__EmbeddedZipArchiveFactory,
  &_swigt__p_Ogre__EmitterCommands__CmdAngle,
  &_swigt__p_Ogre__EmitterCommands__CmdColour,
  &_swigt__p_Ogre__EmitterCommands__CmdColourRangeEnd,
  &_swigt__p_Ogre__EmitterCommands__CmdColourRangeStart,
  &_swigt__p_Ogre__EmitterCommands__CmdDirection,
  &_swigt__p_Ogre__EmitterCommands__CmdDuration,
  &_swigt__p_Ogre__EmitterCommands__CmdEmissionRate,
  &_swigt__p_Ogre__EmitterCommands__CmdEmittedEmitter,
  &_swigt__p_Ogre__EmitterCommands__CmdMaxDuration,
  &_swigt__p_Ogre__EmitterCommands__CmdMaxRepeatDelay,
  &_swigt__p_Ogre__EmitterCommands__CmdMaxTTL,
  &_swigt__p_Ogre__EmitterCommands__CmdMaxVelocity,
  &_swigt__p_Ogre__EmitterCommands__CmdMinDuration,
  &_swigt__p_Ogre__EmitterCommands__CmdMinRepeatDelay,
  &_swigt__p_Ogre__EmitterCommands__CmdMinTTL,
  &_swigt__p_Ogre__EmitterCommands__CmdMinVelocity,
  &_swigt__p_Ogre__EmitterCommands__CmdName,
  &_swigt__p_Ogre__EmitterCommands__CmdPosition,
  &_swigt__p_Ogre__EmitterCommands__CmdRepeatDelay,
  &_swigt__p_Ogre__EmitterCommands__CmdTTL,
  &_swigt__p_Ogre__EmitterCommands__CmdUp,
  &_swigt__p_Ogre__EmitterCommands__CmdVelocity,
  &_swigt__p_Ogre__Entity,
  &_swigt__p_Ogre__EntityFactory,
  &_swigt__p_Ogre__EntityMaterialLodChangedEvent,
  &_swigt__p_Ogre__EntityMeshLodChangedEvent,
  &_swigt__p_Ogre__Exception,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t,
  &_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t,
  &_swigt__p_Ogre__ExceptionFactory,
  &_swigt__p_Ogre__ExternalTextureSource,
  &_swigt__p_Ogre__ExternalTextureSourceManager,
  &_swigt__p_Ogre__FileHandleDataStream,
  &_swigt__p_Ogre__FileInfo,
  &_swigt__p_Ogre__FileNotFoundException,
  &_swigt__p_Ogre__FileStreamDataStream,
  &_swigt__p_Ogre__FileSystemArchive,
  &_swigt__p_Ogre__FileSystemArchiveFactory,
  &_swigt__p_Ogre__FloatGpuParameterControllerValue,
  &_swigt__p_Ogre__FocusedShadowCameraSetup,
  &_swigt__p_Ogre__Font,
  &_swigt__p_Ogre__FontManager,
  &_swigt__p_Ogre__FontPtr,
  &_swigt__p_Ogre__Font__GlyphInfo,
  &_swigt__p_Ogre__FrameEvent,
  &_swigt__p_Ogre__FrameListener,
  &_swigt__p_Ogre__FrameTimeControllerValue,
  &_swigt__p_Ogre__FreeImageCodec,
  &_swigt__p_Ogre__Frustum,
  &_swigt__p_Ogre__FrustumPlane,
  &_swigt__p_Ogre__GpuConstantDefinition,
  &_swigt__p_Ogre__GpuLogicalBufferStruct,
  &_swigt__p_Ogre__GpuLogicalIndexUse,
  &_swigt__p_Ogre__GpuNamedConstants,
  &_swigt__p_Ogre__GpuNamedConstantsSerializer,
  &_swigt__p_Ogre__GpuProgram,
  &_swigt__p_Ogre__GpuProgramManager,
  &_swigt__p_Ogre__GpuProgramParameters,
  &_swigt__p_Ogre__GpuProgramParameters__AutoConstantDefinition,
  &_swigt__p_Ogre__GpuProgramParameters__AutoConstantEntry,
  &_swigt__p_Ogre__GpuProgramPtr,
  &_swigt__p_Ogre__GpuProgramTranslator,
  &_swigt__p_Ogre__GpuProgramUsage,
  &_swigt__p_Ogre__GpuSharedParameters,
  &_swigt__p_Ogre__GpuSharedParametersUsage,
  &_swigt__p_Ogre__Grid2DPageStrategy,
  &_swigt__p_Ogre__Grid2DPageStrategyData,
  &_swigt__p_Ogre__Grid3DPageStrategy,
  &_swigt__p_Ogre__Grid3DPageStrategyData,
  &_swigt__p_Ogre__HardwareBuffer,
  &_swigt__p_Ogre__HardwareBufferLicensee,
  &_swigt__p_Ogre__HardwareBufferManager,
  &_swigt__p_Ogre__HardwareBufferManagerBase,
  &_swigt__p_Ogre__HardwareIndexBuffer,
  &_swigt__p_Ogre__HardwareIndexBufferSharedPtr,
  &_swigt__p_Ogre__HardwareOcclusionQuery,
  &_swigt__p_Ogre__HardwarePixelBuffer,
  &_swigt__p_Ogre__HardwarePixelBufferSharedPtr,
  &_swigt__p_Ogre__HardwareVertexBuffer,
  &_swigt__p_Ogre__HardwareVertexBufferSharedPtr,
  &_swigt__p_Ogre__HashedVectorT_Ogre__Light_p_t,
  &_swigt__p_Ogre__HighLevelGpuProgram,
  &_swigt__p_Ogre__HighLevelGpuProgramFactory,
  &_swigt__p_Ogre__HighLevelGpuProgramManager,
  &_swigt__p_Ogre__HighLevelGpuProgramPtr,
  &_swigt__p_Ogre__IOException,
  &_swigt__p_Ogre__IlluminationPass,
  &_swigt__p_Ogre__Image,
  &_swigt__p_Ogre__ImageCodec,
  &_swigt__p_Ogre__ImportAbstractNode,
  &_swigt__p_Ogre__IndexData,
  &_swigt__p_Ogre__InstanceBatch,
  &_swigt__p_Ogre__InstanceBatchHW,
  &_swigt__p_Ogre__InstanceBatchHW_VTF,
  &_swigt__p_Ogre__InstanceBatchShader,
  &_swigt__p_Ogre__InstanceBatchVTF,
  &_swigt__p_Ogre__InstanceManager,
  &_swigt__p_Ogre__InstancedEntity,
  &_swigt__p_Ogre__InstancedGeometry,
  &_swigt__p_Ogre__InstancedGeometry__BatchInstanceIterator,
  &_swigt__p_Ogre__InternalErrorException,
  &_swigt__p_Ogre__IntersectionSceneQuery,
  &_swigt__p_Ogre__IntersectionSceneQueryListener,
  &_swigt__p_Ogre__IntersectionSceneQueryResult,
  &_swigt__p_Ogre__InvalidParametersException,
  &_swigt__p_Ogre__InvalidStateException,
  &_swigt__p_Ogre__ItemIdentityException,
  &_swigt__p_Ogre__KeyFrame,
  &_swigt__p_Ogre__LayerBlendModeEx,
  &_swigt__p_Ogre__LiSPSMShadowCameraSetup,
  &_swigt__p_Ogre__Light,
  &_swigt__p_Ogre__LightFactory,
  &_swigt__p_Ogre__LinkedSkeletonAnimationSource,
  &_swigt__p_Ogre__LodListener,
  &_swigt__p_Ogre__LodStrategy,
  &_swigt__p_Ogre__LodStrategyManager,
  &_swigt__p_Ogre__Log,
  &_swigt__p_Ogre__LogListener,
  &_swigt__p_Ogre__LogManager,
  &_swigt__p_Ogre__Log__Stream,
  &_swigt__p_Ogre__ManualObject,
  &_swigt__p_Ogre__ManualObjectFactory,
  &_swigt__p_Ogre__ManualObject__ManualObjectSection,
  &_swigt__p_Ogre__ManualResourceLoader,
  &_swigt__p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_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_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__Material,
  &_swigt__p_Ogre__MaterialManager,
  &_swigt__p_Ogre__MaterialManager__Listener,
  &_swigt__p_Ogre__MaterialPtr,
  &_swigt__p_Ogre__MaterialScriptContext,
  &_swigt__p_Ogre__MaterialScriptProgramDefinition,
  &_swigt__p_Ogre__MaterialSerializer,
  &_swigt__p_Ogre__MaterialSerializer__Listener,
  &_swigt__p_Ogre__MaterialTranslator,
  &_swigt__p_Ogre__Math,
  &_swigt__p_Ogre__Matrix3,
  &_swigt__p_Ogre__Matrix4,
  &_swigt__p_Ogre__MemoryDataStream,
  &_swigt__p_Ogre__Mesh,
  &_swigt__p_Ogre__MeshLodUsage,
  &_swigt__p_Ogre__MeshManager,
  &_swigt__p_Ogre__MeshPtr,
  &_swigt__p_Ogre__MeshSerializer,
  &_swigt__p_Ogre__MeshSerializerListener,
  &_swigt__p_Ogre__MovableObject,
  &_swigt__p_Ogre__MovableObjectFactory,
  &_swigt__p_Ogre__MovableObjectLodChangedEvent,
  &_swigt__p_Ogre__MovableObject__Listener,
  &_swigt__p_Ogre__MovablePlane,
  &_swigt__p_Ogre__MultiRenderTarget,
  &_swigt__p_Ogre__NameGenerator,
  &_swigt__p_Ogre__NedPoolingImpl,
  &_swigt__p_Ogre__NedPoolingPolicy,
  &_swigt__p_Ogre__Node,
  &_swigt__p_Ogre__NodeAnimationTrack,
  &_swigt__p_Ogre__Node__DebugRenderable,
  &_swigt__p_Ogre__Node__Listener,
  &_swigt__p_Ogre__NumericAnimationTrack,
  &_swigt__p_Ogre__NumericKeyFrame,
  &_swigt__p_Ogre__ObjectAbstractNode,
  &_swigt__p_Ogre__OptimisedUtil,
  &_swigt__p_Ogre__Overlay,
  &_swigt__p_Ogre__OverlayContainer,
  &_swigt__p_Ogre__OverlayElement,
  &_swigt__p_Ogre__OverlayElementCommands__CmdCaption,
  &_swigt__p_Ogre__OverlayElementCommands__CmdHeight,
  &_swigt__p_Ogre__OverlayElementCommands__CmdHorizontalAlign,
  &_swigt__p_Ogre__OverlayElementCommands__CmdLeft,
  &_swigt__p_Ogre__OverlayElementCommands__CmdMaterial,
  &_swigt__p_Ogre__OverlayElementCommands__CmdMetricsMode,
  &_swigt__p_Ogre__OverlayElementCommands__CmdTop,
  &_swigt__p_Ogre__OverlayElementCommands__CmdVerticalAlign,
  &_swigt__p_Ogre__OverlayElementCommands__CmdVisible,
  &_swigt__p_Ogre__OverlayElementCommands__CmdWidth,
  &_swigt__p_Ogre__OverlayElementFactory,
  &_swigt__p_Ogre__OverlayManager,
  &_swigt__p_Ogre__PSSMShadowCameraSetup,
  &_swigt__p_Ogre__Page,
  &_swigt__p_Ogre__PageContent,
  &_swigt__p_Ogre__PageContentCollection,
  &_swigt__p_Ogre__PageContentCollectionFactory,
  &_swigt__p_Ogre__PageContentFactory,
  &_swigt__p_Ogre__PageManager,
  &_swigt__p_Ogre__PageProvider,
  &_swigt__p_Ogre__PageStrategy,
  &_swigt__p_Ogre__PageStrategyData,
  &_swigt__p_Ogre__PagedWorld,
  &_swigt__p_Ogre__PagedWorldSection,
  &_swigt__p_Ogre__PagedWorldSectionFactory,
  &_swigt__p_Ogre__PanelOverlayElement,
  &_swigt__p_Ogre__PanelOverlayElementFactory,
  &_swigt__p_Ogre__ParamCommand,
  &_swigt__p_Ogre__ParamDictionary,
  &_swigt__p_Ogre__ParameterDef,
  &_swigt__p_Ogre__Particle,
  &_swigt__p_Ogre__ParticleAffector,
  &_swigt__p_Ogre__ParticleAffectorFactory,
  &_swigt__p_Ogre__ParticleAffectorTranslator,
  &_swigt__p_Ogre__ParticleEmitter,
  &_swigt__p_Ogre__ParticleEmitterFactory,
  &_swigt__p_Ogre__ParticleEmitterTranslator,
  &_swigt__p_Ogre__ParticleIterator,
  &_swigt__p_Ogre__ParticleSystem,
  &_swigt__p_Ogre__ParticleSystemFactory,
  &_swigt__p_Ogre__ParticleSystemManager,
  &_swigt__p_Ogre__ParticleSystemRenderer,
  &_swigt__p_Ogre__ParticleSystemRendererFactory,
  &_swigt__p_Ogre__ParticleSystemTranslator,
  &_swigt__p_Ogre__ParticleVisualData,
  &_swigt__p_Ogre__Pass,
  &_swigt__p_Ogre__PassTranslator,
  &_swigt__p_Ogre__Pass__HashFunc,
  &_swigt__p_Ogre__PassthroughControllerFunction,
  &_swigt__p_Ogre__PatchMesh,
  &_swigt__p_Ogre__PatchMeshPtr,
  &_swigt__p_Ogre__PatchSurface,
  &_swigt__p_Ogre__PixelBox,
  &_swigt__p_Ogre__PixelCountLodStrategy,
  &_swigt__p_Ogre__PixelUtil,
  &_swigt__p_Ogre__Plane,
  &_swigt__p_Ogre__PlaneBoundedVolume,
  &_swigt__p_Ogre__PlaneBoundedVolumeListSceneQuery,
  &_swigt__p_Ogre__PlaneOptimalShadowCameraSetup,
  &_swigt__p_Ogre__PlatformInformation,
  &_swigt__p_Ogre__Plugin,
  &_swigt__p_Ogre__Polygon,
  &_swigt__p_Ogre__Pose,
  &_swigt__p_Ogre__PreApplyTextureAliasesScriptCompilerEvent,
  &_swigt__p_Ogre__PrefabFactory,
  &_swigt__p_Ogre__ProcessNameExclusionScriptCompilerEvent,
  &_swigt__p_Ogre__ProcessResourceNameScriptCompilerEvent,
  &_swigt__p_Ogre__Profile,
  &_swigt__p_Ogre__Profiler,
  &_swigt__p_Ogre__PropertyAbstractNode,
  &_swigt__p_Ogre__Quaternion,
  &_swigt__p_Ogre__QueuedRenderableCollection,
  &_swigt__p_Ogre__QueuedRenderableVisitor,
  &_swigt__p_Ogre__Radian,
  &_swigt__p_Ogre__Ray,
  &_swigt__p_Ogre__RaySceneQuery,
  &_swigt__p_Ogre__RaySceneQueryListener,
  &_swigt__p_Ogre__RaySceneQueryResultEntry,
  &_swigt__p_Ogre__Rectangle,
  &_swigt__p_Ogre__Rectangle2D,
  &_swigt__p_Ogre__RegionSceneQuery,
  &_swigt__p_Ogre__RenderObjectListener,
  &_swigt__p_Ogre__RenderOperation,
  &_swigt__p_Ogre__RenderPriorityGroup,
  &_swigt__p_Ogre__RenderQueue,
  &_swigt__p_Ogre__RenderQueueGroup,
  &_swigt__p_Ogre__RenderQueueGroup__ConstPriorityMapIterator,
  &_swigt__p_Ogre__RenderQueueGroup__PriorityMapIterator,
  &_swigt__p_Ogre__RenderQueueInvocation,
  &_swigt__p_Ogre__RenderQueueInvocationSequence,
  &_swigt__p_Ogre__RenderQueueListener,
  &_swigt__p_Ogre__RenderQueue__RenderableListener,
  &_swigt__p_Ogre__RenderSystem,
  &_swigt__p_Ogre__RenderSystemCapabilities,
  &_swigt__p_Ogre__RenderSystemCapabilitiesManager,
  &_swigt__p_Ogre__RenderSystemCapabilitiesSerializer,
  &_swigt__p_Ogre__RenderSystem__Listener,
  &_swigt__p_Ogre__RenderSystem__RenderSystemContext,
  &_swigt__p_Ogre__RenderTarget,
  &_swigt__p_Ogre__RenderTargetEvent,
  &_swigt__p_Ogre__RenderTargetListener,
  &_swigt__p_Ogre__RenderTargetViewportEvent,
  &_swigt__p_Ogre__RenderTarget__FrameStats,
  &_swigt__p_Ogre__RenderTarget__Impl,
  &_swigt__p_Ogre__RenderTexture,
  &_swigt__p_Ogre__RenderToVertexBuffer,
  &_swigt__p_Ogre__RenderWindow,
  &_swigt__p_Ogre__RenderWindowDescription,
  &_swigt__p_Ogre__Renderable,
  &_swigt__p_Ogre__RenderablePass,
  &_swigt__p_Ogre__Renderable__RenderSystemData,
  &_swigt__p_Ogre__Renderable__Visitor,
  &_swigt__p_Ogre__RenderingAPIException,
  &_swigt__p_Ogre__Resource,
  &_swigt__p_Ogre__ResourceBackgroundQueue,
  &_swigt__p_Ogre__ResourceBackgroundQueue__Listener,
  &_swigt__p_Ogre__ResourceGroupListener,
  &_swigt__p_Ogre__ResourceGroupManager,
  &_swigt__p_Ogre__ResourceGroupManager__ResourceManagerIterator,
  &_swigt__p_Ogre__ResourceLoadingListener,
  &_swigt__p_Ogre__ResourceManager,
  &_swigt__p_Ogre__ResourceManager__ResourceMapIterator,
  &_swigt__p_Ogre__ResourceManager__ResourcePool,
  &_swigt__p_Ogre__Resource__Listener,
  &_swigt__p_Ogre__RibbonTrail,
  &_swigt__p_Ogre__RibbonTrailFactory,
  &_swigt__p_Ogre__Root,
  &_swigt__p_Ogre__Root__MovableObjectFactoryIterator,
  &_swigt__p_Ogre__RotationalSpline,
  &_swigt__p_Ogre__RuntimeAssertionException,
  &_swigt__p_Ogre__ScaleControllerFunction,
  &_swigt__p_Ogre__SceneManager,
  &_swigt__p_Ogre__SceneManagerEnumerator,
  &_swigt__p_Ogre__SceneManagerEnumerator__MetaDataIterator,
  &_swigt__p_Ogre__SceneManagerEnumerator__SceneManagerIterator,
  &_swigt__p_Ogre__SceneManagerFactory,
  &_swigt__p_Ogre__SceneManagerMetaData,
  &_swigt__p_Ogre__SceneManager__AnimationIterator,
  &_swigt__p_Ogre__SceneManager__CameraIterator,
  &_swigt__p_Ogre__SceneManager__Listener,
  &_swigt__p_Ogre__SceneManager__MovableObjectIterator,
  &_swigt__p_Ogre__SceneManager__RenderContext,
  &_swigt__p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor,
  &_swigt__p_Ogre__SceneManager__SkyBoxGenParameters,
  &_swigt__p_Ogre__SceneManager__SkyDomeGenParameters,
  &_swigt__p_Ogre__SceneManager__SkyPlaneGenParameters,
  &_swigt__p_Ogre__SceneNode,
  &_swigt__p_Ogre__SceneQuery,
  &_swigt__p_Ogre__SceneQueryListener,
  &_swigt__p_Ogre__SceneQueryResult,
  &_swigt__p_Ogre__SceneQuery__WorldFragment,
  &_swigt__p_Ogre__ScriptCompiler,
  &_swigt__p_Ogre__ScriptCompilerEvent,
  &_swigt__p_Ogre__ScriptCompilerListener,
  &_swigt__p_Ogre__ScriptCompilerManager,
  &_swigt__p_Ogre__ScriptLexer,
  &_swigt__p_Ogre__ScriptLoader,
  &_swigt__p_Ogre__ScriptParser,
  &_swigt__p_Ogre__ScriptToken,
  &_swigt__p_Ogre__ScriptTranslator,
  &_swigt__p_Ogre__ScriptTranslatorManager,
  &_swigt__p_Ogre__Serializer,
  &_swigt__p_Ogre__ShadowCameraSetup,
  &_swigt__p_Ogre__ShadowCaster,
  &_swigt__p_Ogre__ShadowRenderable,
  &_swigt__p_Ogre__ShadowTextureConfig,
  &_swigt__p_Ogre__ShadowTextureManager,
  &_swigt__p_Ogre__ShadowVolumeExtrudeProgram,
  &_swigt__p_Ogre__SharedParamsTranslator,
  &_swigt__p_Ogre__SharedPtrT_Ogre__AbstractNode_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__AnimableValue_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__CodecData_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__Material_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,
  &_swigt__p_Ogre__SharedPtrT_Ogre__Mesh_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__SimplePageContentCollection,
  &_swigt__p_Ogre__SimplePageContentCollectionFactory,
  &_swigt__p_Ogre__SimpleRenderable,
  &_swigt__p_Ogre__SimpleSpline,
  &_swigt__p_Ogre__Skeleton,
  &_swigt__p_Ogre__SkeletonInstance,
  &_swigt__p_Ogre__SkeletonManager,
  &_swigt__p_Ogre__SkeletonPtr,
  &_swigt__p_Ogre__SkeletonSerializer,
  &_swigt__p_Ogre__Sphere,
  &_swigt__p_Ogre__SphereSceneQuery,
  &_swigt__p_Ogre__StaticFaceGroup,
  &_swigt__p_Ogre__StaticGeometry,
  &_swigt__p_Ogre__StaticPluginLoader,
  &_swigt__p_Ogre__StreamSerialiser,
  &_swigt__p_Ogre__StreamSerialiser__Chunk,
  &_swigt__p_Ogre__StringConverter,
  &_swigt__p_Ogre__StringInterface,
  &_swigt__p_Ogre__StringUtil,
  &_swigt__p_Ogre__SubEntity,
  &_swigt__p_Ogre__SubMesh,
  &_swigt__p_Ogre__TRectT_float_t,
  &_swigt__p_Ogre__TRectT_long_t,
  &_swigt__p_Ogre__TagPoint,
  &_swigt__p_Ogre__TangentSpaceCalc,
  &_swigt__p_Ogre__TangentSpaceCalc__Result,
  &_swigt__p_Ogre__Technique,
  &_swigt__p_Ogre__TechniqueTranslator,
  &_swigt__p_Ogre__TempBlendedBufferInfo,
  &_swigt__p_Ogre__Terrain,
  &_swigt__p_Ogre__TerrainGlobalOptions,
  &_swigt__p_Ogre__TerrainGroup,
  &_swigt__p_Ogre__TerrainGroup__RayResult,
  &_swigt__p_Ogre__TerrainGroup__TerrainSlotDefinition,
  &_swigt__p_Ogre__TerrainLayerBlendMap,
  &_swigt__p_Ogre__TerrainLayerDeclaration,
  &_swigt__p_Ogre__TerrainLayerSampler,
  &_swigt__p_Ogre__TerrainLayerSamplerElement,
  &_swigt__p_Ogre__TerrainMaterialGenerator,
  &_swigt__p_Ogre__TerrainMaterialGeneratorA,
  &_swigt__p_Ogre__TerrainMaterialGenerator__Profile,
  &_swigt__p_Ogre__TerrainPagedWorldSection,
  &_swigt__p_Ogre__TerrainPaging,
  &_swigt__p_Ogre__TerrainQuadTreeNode,
  &_swigt__p_Ogre__TerrainQuadTreeNode__LodLevel,
  &_swigt__p_Ogre__Terrain__GpuBufferAllocator,
  &_swigt__p_Ogre__Terrain__ImportData,
  &_swigt__p_Ogre__TexCoordModifierControllerValue,
  &_swigt__p_Ogre__TextAreaOverlayElement,
  &_swigt__p_Ogre__TextAreaOverlayElementFactory,
  &_swigt__p_Ogre__Texture,
  &_swigt__p_Ogre__TextureFrameControllerValue,
  &_swigt__p_Ogre__TextureManager,
  &_swigt__p_Ogre__TexturePtr,
  &_swigt__p_Ogre__TextureSourceTranslator,
  &_swigt__p_Ogre__TextureUnitState,
  &_swigt__p_Ogre__TextureUnitState__TextureEffect,
  &_swigt__p_Ogre__TextureUnitState__UVWAddressingMode,
  &_swigt__p_Ogre__TextureUnitTranslator,
  &_swigt__p_Ogre__TimeIndex,
  &_swigt__p_Ogre__Timer,
  &_swigt__p_Ogre__TransformKeyFrame,
  &_swigt__p_Ogre__UTFString,
  &_swigt__p_Ogre__UTFString___const_fwd_iterator,
  &_swigt__p_Ogre__UTFString___const_rev_iterator,
  &_swigt__p_Ogre__UTFString___fwd_iterator,
  &_swigt__p_Ogre__UTFString___rev_iterator,
  &_swigt__p_Ogre__UnifiedHighLevelGpuProgram,
  &_swigt__p_Ogre__UnifiedHighLevelGpuProgramFactory,
  &_swigt__p_Ogre__UnimplementedException,
  &_swigt__p_Ogre__UserObjectBindings,
  &_swigt__p_Ogre__VariableAccessAbstractNode,
  &_swigt__p_Ogre__Vector2,
  &_swigt__p_Ogre__Vector3,
  &_swigt__p_Ogre__Vector4,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_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,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t,
  &_swigt__p_Ogre__VertexAnimationTrack,
  &_swigt__p_Ogre__VertexBoneAssignment_s,
  &_swigt__p_Ogre__VertexBufferBinding,
  &_swigt__p_Ogre__VertexCacheProfiler,
  &_swigt__p_Ogre__VertexData,
  &_swigt__p_Ogre__VertexDeclaration,
  &_swigt__p_Ogre__VertexElement,
  &_swigt__p_Ogre__VertexMorphKeyFrame,
  &_swigt__p_Ogre__VertexPoseKeyFrame,
  &_swigt__p_Ogre__ViewPoint,
  &_swigt__p_Ogre__Viewport,
  &_swigt__p_Ogre__Viewport__Listener,
  &_swigt__p_Ogre__VisibleObjectsBoundsInfo,
  &_swigt__p_Ogre__WaveformControllerFunction,
  &_swigt__p_Ogre__WindowEventListener,
  &_swigt__p_Ogre__WindowEventUtilities,
  &_swigt__p_Ogre__WireBoundingBox,
  &_swigt__p_Ogre__WorkQueue,
  &_swigt__p_Ogre__WorkQueue__Request,
  &_swigt__p_Ogre__WorkQueue__RequestHandler,
  &_swigt__p_Ogre__WorkQueue__Response,
  &_swigt__p_Ogre__WorkQueue__ResponseHandler,
  &_swigt__p_Ogre__ZipArchive,
  &_swigt__p_Ogre__ZipArchiveFactory,
  &_swigt__p_Ogre__ZipDataStream,
  &_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__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_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__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_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__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_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__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_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,
  &_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__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_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,
  &_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_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_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__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_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__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_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__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_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__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_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__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_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__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_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__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_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__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_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__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_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__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_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__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_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_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type,
  &_swigt__p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_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_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_ResourcePool,
  &_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_a_3__float,
  &_swigt__p_bool,
  &_swigt__p_char,
  &_swigt__p_code_point,
  &_swigt__p_const_iterator,
  &_swigt__p_const_reverse_iterator,
  &_swigt__p_double,
  &_swigt__p_dstring,
  &_swigt__p_f_size_t_p_void_size_t__bool,
  &_swigt__p_float,
  &_swigt__p_int,
  &_swigt__p_iterator,
  &_swigt__p_long,
  &_swigt__p_long_long,
  &_swigt__p_p_Ogre__KeyFrame,
  &_swigt__p_p_Ogre__LinkedSkeletonAnimationSource,
  &_swigt__p_p_Ogre__Matrix4,
  &_swigt__p_p_Ogre__NumericKeyFrame,
  &_swigt__p_p_Ogre__Terrain,
  &_swigt__p_p_Ogre__TransformKeyFrame,
  &_swigt__p_p_Ogre__VertexMorphKeyFrame,
  &_swigt__p_p_Ogre__VertexPoseKeyFrame,
  &_swigt__p_p_char,
  &_swigt__p_p_float,
  &_swigt__p_p_unsigned_char,
  &_swigt__p_p_unsigned_int,
  &_swigt__p_p_unsigned_short,
  &_swigt__p_p_void,
  &_swigt__p_reverse_iterator,
  &_swigt__p_short,
  &_swigt__p_size_t,
  &_swigt__p_size_type,
  &_swigt__p_std__basic_stringT_unsigned_int_t,
  &_swigt__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  &_swigt__p_std__exception,
  &_swigt__p_std__fstream,
  &_swigt__p_std__ifstream,
  &_swigt__p_std__ios__fmtflags,
  &_swigt__p_std__ostream,
  &_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__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t,
  &_swigt__p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t,
  &_swigt__p_std__pairT_bool_Ogre__Vector3_t,
  &_swigt__p_std__pairT_bool_float_t,
  &_swigt__p_std__pairT_bool_std__string_t,
  &_swigt__p_std__pairT_size_t_size_t_t,
  &_swigt__p_std__pairT_unsigned_char_unsigned_char_t,
  &_swigt__p_std__pairT_unsigned_int_unsigned_int_t,
  &_swigt__p_std__string,
  &_swigt__p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t,
  &_swigt__p_std__type_info,
  &_swigt__p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t,
  &_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  &_swigt__p_std__wostream,
  &_swigt__p_std__wstring,
  &_swigt__p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t,
  &_swigt__p_swig__ConstIterator,
  &_swigt__p_swig__GC_VALUE,
  &_swigt__p_swig__Iterator,
  &_swigt__p_time_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_void,
  &_swigt__p_wchar_t,
  &_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_AutoConstantEntry[] = {  {&_swigt__p_AutoConstantEntry, 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_FILE[] = {  {&_swigt__p_FILE, 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_GPUDeviceNameRule[] = {  {&_swigt__p_GPUDeviceNameRule, 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_GPUVendorRule[] = {  {&_swigt__p_GPUVendorRule, 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_ImportData[] = {  {&_swigt__p_ImportData, 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_Intp[] = {  {&_swigt__p_Intp, 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__AbstractNode[] = {  {&_swigt__p_Ogre__AbstractNode, 0, 0, 0},  {&_swigt__p_Ogre__AtomAbstractNode, _p_Ogre__AtomAbstractNodeTo_p_Ogre__AbstractNode, 0, 0},  {&_swigt__p_Ogre__ObjectAbstractNode, _p_Ogre__ObjectAbstractNodeTo_p_Ogre__AbstractNode, 0, 0},  {&_swigt__p_Ogre__PropertyAbstractNode, _p_Ogre__PropertyAbstractNodeTo_p_Ogre__AbstractNode, 0, 0},  {&_swigt__p_Ogre__ImportAbstractNode, _p_Ogre__ImportAbstractNodeTo_p_Ogre__AbstractNode, 0, 0},  {&_swigt__p_Ogre__VariableAccessAbstractNode, _p_Ogre__VariableAccessAbstractNodeTo_p_Ogre__AbstractNode, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AlignedMemory[] = {  {&_swigt__p_Ogre__AlignedMemory, 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__Angle[] = {  {&_swigt__p_Ogre__Angle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimableObject[] = {  {&_swigt__p_Ogre__InstanceBatchVTF, _p_Ogre__InstanceBatchVTFTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__BaseInstanceBatchVTF, _p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__ManualObject, _p_Ogre__ManualObjectTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__Camera, _p_Ogre__CameraTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__BillboardChain, _p_Ogre__BillboardChainTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__SimpleRenderable, _p_Ogre__SimpleRenderableTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__WireBoundingBox, _p_Ogre__WireBoundingBoxTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__Entity, _p_Ogre__EntityTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__ParticleSystem, _p_Ogre__ParticleSystemTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW, _p_Ogre__InstanceBatchHWTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW_VTF, _p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__MovablePlane, _p_Ogre__MovablePlaneTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__InstancedEntity, _p_Ogre__InstancedEntityTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__AnimableObject, 0, 0, 0},  {&_swigt__p_Ogre__Light, _p_Ogre__LightTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__BillboardSet, _p_Ogre__BillboardSetTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatch, _p_Ogre__InstanceBatchTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatchShader, _p_Ogre__InstanceBatchShaderTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__MovableObject, _p_Ogre__MovableObjectTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__Frustum, _p_Ogre__FrustumTo_p_Ogre__AnimableObject, 0, 0},  {&_swigt__p_Ogre__RibbonTrail, _p_Ogre__RibbonTrailTo_p_Ogre__AnimableObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimableValue[] = {  {&_swigt__p_Ogre__AnimableValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Animation[] = {  {&_swigt__p_Ogre__Animation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimationContainer[] = {  {&_swigt__p_Ogre__SkeletonInstance, _p_Ogre__SkeletonInstanceTo_p_Ogre__AnimationContainer, 0, 0},  {&_swigt__p_Ogre__Mesh, _p_Ogre__MeshTo_p_Ogre__AnimationContainer, 0, 0},  {&_swigt__p_Ogre__AnimationContainer, 0, 0, 0},  {&_swigt__p_Ogre__PatchMesh, _p_Ogre__PatchMeshTo_p_Ogre__AnimationContainer, 0, 0},  {&_swigt__p_Ogre__Skeleton, _p_Ogre__SkeletonTo_p_Ogre__AnimationContainer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimationControllerFunction[] = {  {&_swigt__p_Ogre__AnimationControllerFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimationState[] = {  {&_swigt__p_Ogre__AnimationState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimationStateControllerValue[] = {  {&_swigt__p_Ogre__AnimationStateControllerValue, 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__AnimationStateSet[] = {  {&_swigt__p_Ogre__AnimationStateSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimationTrack[] = {  {&_swigt__p_Ogre__AnimationTrack, 0, 0, 0},  {&_swigt__p_Ogre__NumericAnimationTrack, _p_Ogre__NumericAnimationTrackTo_p_Ogre__AnimationTrack, 0, 0},  {&_swigt__p_Ogre__NodeAnimationTrack, _p_Ogre__NodeAnimationTrackTo_p_Ogre__AnimationTrack, 0, 0},  {&_swigt__p_Ogre__VertexAnimationTrack, _p_Ogre__VertexAnimationTrackTo_p_Ogre__AnimationTrack, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnimationTrack__Listener[] = {  {&_swigt__p_Ogre__AnimationTrack__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Any[] = {  {&_swigt__p_Ogre__Any, 0, 0, 0},  {&_swigt__p_Ogre__AnyNumeric, _p_Ogre__AnyNumericTo_p_Ogre__Any, 0, 0},  {&_swigt__p_Ogre__AnyVALUE, _p_Ogre__AnyVALUETo_p_Ogre__Any, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnyNumeric[] = {  {&_swigt__p_Ogre__AnyNumeric, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AnyVALUE[] = {  {&_swigt__p_Ogre__AnyVALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Archive[] = {  {&_swigt__p_Ogre__Archive, 0, 0, 0},  {&_swigt__p_Ogre__FileSystemArchive, _p_Ogre__FileSystemArchiveTo_p_Ogre__Archive, 0, 0},  {&_swigt__p_Ogre__ZipArchive, _p_Ogre__ZipArchiveTo_p_Ogre__Archive, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ArchiveFactory[] = {  {&_swigt__p_Ogre__ArchiveFactory, 0, 0, 0},  {&_swigt__p_Ogre__FileSystemArchiveFactory, _p_Ogre__FileSystemArchiveFactoryTo_p_Ogre__ArchiveFactory, 0, 0},  {&_swigt__p_Ogre__ZipArchiveFactory, _p_Ogre__ZipArchiveFactoryTo_p_Ogre__ArchiveFactory, 0, 0},  {&_swigt__p_Ogre__EmbeddedZipArchiveFactory, _p_Ogre__EmbeddedZipArchiveFactoryTo_p_Ogre__ArchiveFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ArchiveManager[] = {  {&_swigt__p_Ogre__ArchiveManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AtomAbstractNode[] = {  {&_swigt__p_Ogre__AtomAbstractNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__AutoParamDataSource[] = {  {&_swigt__p_Ogre__AutoParamDataSource, 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__AxisAlignedBoxSceneQuery[] = {  {&_swigt__p_Ogre__AxisAlignedBoxSceneQuery, 0, 0, 0},  {&_swigt__p_Ogre__DefaultAxisAlignedBoxSceneQuery, _p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__AxisAlignedBoxSceneQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BackgroundProcessResult[] = {  {&_swigt__p_Ogre__BackgroundProcessResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BaseInstanceBatchVTF[] = {  {&_swigt__p_Ogre__InstanceBatchHW_VTF, _p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__BaseInstanceBatchVTF, 0, 0},  {&_swigt__p_Ogre__BaseInstanceBatchVTF, 0, 0, 0},  {&_swigt__p_Ogre__InstanceBatchVTF, _p_Ogre__InstanceBatchVTFTo_p_Ogre__BaseInstanceBatchVTF, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Billboard[] = {  {&_swigt__p_Ogre__Billboard, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BillboardChain[] = {  {&_swigt__p_Ogre__RibbonTrail, _p_Ogre__RibbonTrailTo_p_Ogre__BillboardChain, 0, 0},  {&_swigt__p_Ogre__BillboardChain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BillboardChainFactory[] = {  {&_swigt__p_Ogre__BillboardChainFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BillboardChain__Element[] = {  {&_swigt__p_Ogre__BillboardChain__Element, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BillboardParticleRenderer[] = {  {&_swigt__p_Ogre__BillboardParticleRenderer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BillboardParticleRendererFactory[] = {  {&_swigt__p_Ogre__BillboardParticleRendererFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BillboardSet[] = {  {&_swigt__p_Ogre__BillboardSet, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BillboardSetFactory[] = {  {&_swigt__p_Ogre__BillboardSetFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Bitwise[] = {  {&_swigt__p_Ogre__Bitwise, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Bone[] = {  {&_swigt__p_Ogre__TagPoint, _p_Ogre__TagPointTo_p_Ogre__Bone, 0, 0},  {&_swigt__p_Ogre__Bone, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BorderPanelOverlayElement[] = {  {&_swigt__p_Ogre__BorderPanelOverlayElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BorderPanelOverlayElementFactory[] = {  {&_swigt__p_Ogre__BorderPanelOverlayElementFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BorderRenderable[] = {  {&_swigt__p_Ogre__BorderRenderable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Box[] = {  {&_swigt__p_Ogre__PixelBox, _p_Ogre__PixelBoxTo_p_Ogre__Box, 0, 0},  {&_swigt__p_Ogre__Box, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__BuiltinScriptTranslatorManager[] = {  {&_swigt__p_Ogre__BuiltinScriptTranslatorManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Camera[] = {  {&_swigt__p_Ogre__Camera, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Camera__Listener[] = {  {&_swigt__p_Ogre__Camera__Listener, 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__Codec[] = {  {&_swigt__p_Ogre__ImageCodec, _p_Ogre__ImageCodecTo_p_Ogre__Codec, 0, 0},  {&_swigt__p_Ogre__DDSCodec, _p_Ogre__DDSCodecTo_p_Ogre__Codec, 0, 0},  {&_swigt__p_Ogre__FreeImageCodec, _p_Ogre__FreeImageCodecTo_p_Ogre__Codec, 0, 0},  {&_swigt__p_Ogre__Codec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ColourValue[] = {  {&_swigt__p_Ogre__ColourValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionPass[] = {  {&_swigt__p_Ogre__CompositionPass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionPassTranslator[] = {  {&_swigt__p_Ogre__CompositionPassTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionPass__InputTex[] = {  {&_swigt__p_Ogre__CompositionPass__InputTex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionTargetPass[] = {  {&_swigt__p_Ogre__CompositionTargetPass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionTargetPassTranslator[] = {  {&_swigt__p_Ogre__CompositionTargetPassTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionTechnique[] = {  {&_swigt__p_Ogre__CompositionTechnique, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionTechniqueTranslator[] = {  {&_swigt__p_Ogre__CompositionTechniqueTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositionTechnique__TextureDefinition[] = {  {&_swigt__p_Ogre__CompositionTechnique__TextureDefinition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Compositor[] = {  {&_swigt__p_Ogre__Compositor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorChain[] = {  {&_swigt__p_Ogre__CompositorChain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorInstance[] = {  {&_swigt__p_Ogre__CompositorInstance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorInstance__Listener[] = {  {&_swigt__p_Ogre__CompositorInstance__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorInstance__RenderSystemOperation[] = {  {&_swigt__p_Ogre__CompositorInstance__RenderSystemOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorInstance__TargetOperation[] = {  {&_swigt__p_Ogre__CompositorInstance__TargetOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorLogic[] = {  {&_swigt__p_Ogre__CompositorLogic, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorManager[] = {  {&_swigt__p_Ogre__CompositorManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorPtr[] = {  {&_swigt__p_Ogre__CompositorPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CompositorTranslator[] = {  {&_swigt__p_Ogre__CompositorTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConcreteNode[] = {  {&_swigt__p_Ogre__ConcreteNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConfigFile[] = {  {&_swigt__p_Ogre__ConfigFile, 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__RenderQueueGroupMap_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__RenderQueueGroupMap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 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__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_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_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_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_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_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__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ControllerManager[] = {  {&_swigt__p_Ogre__ControllerManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ControllerT_float_t[] = {  {&_swigt__p_Ogre__ControllerT_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ConvexBody[] = {  {&_swigt__p_Ogre__ConvexBody, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CreateCompositorScriptCompilerEvent[] = {  {&_swigt__p_Ogre__CreateCompositorScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CreateGpuProgramScriptCompilerEvent[] = {  {&_swigt__p_Ogre__CreateGpuProgramScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CreateGpuSharedParametersScriptCompilerEvent[] = {  {&_swigt__p_Ogre__CreateGpuSharedParametersScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent[] = {  {&_swigt__p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CreateMaterialScriptCompilerEvent[] = {  {&_swigt__p_Ogre__CreateMaterialScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CreateParticleSystemScriptCompilerEvent[] = {  {&_swigt__p_Ogre__CreateParticleSystemScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__CustomCompositionPass[] = {  {&_swigt__p_Ogre__CustomCompositionPass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DDSCodec[] = {  {&_swigt__p_Ogre__DDSCodec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ZipDataStream[] = {{&_swigt__p_Ogre__ZipDataStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DataStream[] = {  {&_swigt__p_Ogre__DataStream, 0, 0, 0},  {&_swigt__p_Ogre__MemoryDataStream, _p_Ogre__MemoryDataStreamTo_p_Ogre__DataStream, 0, 0},  {&_swigt__p_Ogre__FileStreamDataStream, _p_Ogre__FileStreamDataStreamTo_p_Ogre__DataStream, 0, 0},  {&_swigt__p_Ogre__FileHandleDataStream, _p_Ogre__FileHandleDataStreamTo_p_Ogre__DataStream, 0, 0},  {&_swigt__p_Ogre__DeflateStream, _p_Ogre__DeflateStreamTo_p_Ogre__DataStream, 0, 0},  {&_swigt__p_Ogre__ZipDataStream, _p_Ogre__ZipDataStreamTo_p_Ogre__DataStream, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultAxisAlignedBoxSceneQuery[] = {  {&_swigt__p_Ogre__DefaultAxisAlignedBoxSceneQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultHardwareBufferManager[] = {  {&_swigt__p_Ogre__DefaultHardwareBufferManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultHardwareBufferManagerBase[] = {  {&_swigt__p_Ogre__DefaultHardwareBufferManagerBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultHardwareIndexBuffer[] = {  {&_swigt__p_Ogre__DefaultHardwareIndexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultHardwareVertexBuffer[] = {  {&_swigt__p_Ogre__DefaultHardwareVertexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultIntersectionSceneQuery[] = {  {&_swigt__p_Ogre__DefaultIntersectionSceneQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery[] = {  {&_swigt__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultRaySceneQuery[] = {  {&_swigt__p_Ogre__DefaultRaySceneQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultSceneManager[] = {  {&_swigt__p_Ogre__DefaultSceneManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultSceneManagerFactory[] = {  {&_swigt__p_Ogre__DefaultSceneManagerFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultShadowCameraSetup[] = {  {&_swigt__p_Ogre__DefaultShadowCameraSetup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultSphereSceneQuery[] = {  {&_swigt__p_Ogre__DefaultSphereSceneQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DefaultWorkQueueBase[] = {  {&_swigt__p_Ogre__DefaultWorkQueueBase, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DeflateStream[] = {  {&_swigt__p_Ogre__DeflateStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Degree[] = {  {&_swigt__p_Ogre__Degree, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DepthBuffer[] = {  {&_swigt__p_Ogre__DepthBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DistanceLodStrategy[] = {  {&_swigt__p_Ogre__DistanceLodStrategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DriverVersion[] = {  {&_swigt__p_Ogre__DriverVersion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DualQuaternion[] = {  {&_swigt__p_Ogre__DualQuaternion, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DynLib[] = {  {&_swigt__p_Ogre__DynLib, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__DynLibManager[] = {  {&_swigt__p_Ogre__DynLibManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EdgeData[] = {  {&_swigt__p_Ogre__EdgeData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EdgeData__Triangle[] = {  {&_swigt__p_Ogre__EdgeData__Triangle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EdgeListBuilder[] = {  {&_swigt__p_Ogre__EdgeListBuilder, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmbeddedZipArchiveFactory[] = {  {&_swigt__p_Ogre__EmbeddedZipArchiveFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdAngle[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdAngle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdColour[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdColour, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdColourRangeEnd[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdColourRangeEnd, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdColourRangeStart[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdColourRangeStart, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdDirection[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdDirection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdDuration[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdDuration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdEmissionRate[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdEmissionRate, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdEmittedEmitter[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdEmittedEmitter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMaxDuration[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMaxDuration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMaxRepeatDelay[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMaxRepeatDelay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMaxTTL[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMaxTTL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMaxVelocity[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMaxVelocity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMinDuration[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMinDuration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMinRepeatDelay[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMinRepeatDelay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMinTTL[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMinTTL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdMinVelocity[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdMinVelocity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdName[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdName, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdPosition[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdPosition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdRepeatDelay[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdRepeatDelay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdTTL[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdTTL, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdUp[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdUp, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EmitterCommands__CmdVelocity[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdVelocity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Entity[] = {  {&_swigt__p_Ogre__Entity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EntityFactory[] = {  {&_swigt__p_Ogre__EntityFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EntityMaterialLodChangedEvent[] = {  {&_swigt__p_Ogre__EntityMaterialLodChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__EntityMeshLodChangedEvent[] = {  {&_swigt__p_Ogre__EntityMeshLodChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Exception[] = {  {&_swigt__p_Ogre__Exception, 0, 0, 0},  {&_swigt__p_Ogre__UnimplementedException, _p_Ogre__UnimplementedExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__FileNotFoundException, _p_Ogre__FileNotFoundExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__IOException, _p_Ogre__IOExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__InvalidStateException, _p_Ogre__InvalidStateExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__InvalidParametersException, _p_Ogre__InvalidParametersExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__ItemIdentityException, _p_Ogre__ItemIdentityExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__InternalErrorException, _p_Ogre__InternalErrorExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__RenderingAPIException, _p_Ogre__RenderingAPIExceptionTo_p_Ogre__Exception, 0, 0},  {&_swigt__p_Ogre__RuntimeAssertionException, _p_Ogre__RuntimeAssertionExceptionTo_p_Ogre__Exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t[] = {  {&_swigt__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExceptionFactory[] = {  {&_swigt__p_Ogre__ExceptionFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExternalTextureSource[] = {  {&_swigt__p_Ogre__ExternalTextureSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ExternalTextureSourceManager[] = {  {&_swigt__p_Ogre__ExternalTextureSourceManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FileHandleDataStream[] = {  {&_swigt__p_Ogre__FileHandleDataStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FileInfo[] = {  {&_swigt__p_Ogre__FileInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FileNotFoundException[] = {  {&_swigt__p_Ogre__FileNotFoundException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FileStreamDataStream[] = {  {&_swigt__p_Ogre__FileStreamDataStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FileSystemArchive[] = {  {&_swigt__p_Ogre__FileSystemArchive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FileSystemArchiveFactory[] = {  {&_swigt__p_Ogre__FileSystemArchiveFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FloatGpuParameterControllerValue[] = {  {&_swigt__p_Ogre__FloatGpuParameterControllerValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FocusedShadowCameraSetup[] = {  {&_swigt__p_Ogre__FocusedShadowCameraSetup, 0, 0, 0},  {&_swigt__p_Ogre__LiSPSMShadowCameraSetup, _p_Ogre__LiSPSMShadowCameraSetupTo_p_Ogre__FocusedShadowCameraSetup, 0, 0},  {&_swigt__p_Ogre__PSSMShadowCameraSetup, _p_Ogre__PSSMShadowCameraSetupTo_p_Ogre__FocusedShadowCameraSetup, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Font[] = {  {&_swigt__p_Ogre__Font, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FontManager[] = {  {&_swigt__p_Ogre__FontManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FontPtr[] = {  {&_swigt__p_Ogre__FontPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Font__GlyphInfo[] = {  {&_swigt__p_Ogre__Font__GlyphInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FrameEvent[] = {  {&_swigt__p_Ogre__FrameEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FrameListener[] = {  {&_swigt__p_Ogre__FrameTimeControllerValue, _p_Ogre__FrameTimeControllerValueTo_p_Ogre__FrameListener, 0, 0},  {&_swigt__p_Ogre__FrameListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FrameTimeControllerValue[] = {  {&_swigt__p_Ogre__FrameTimeControllerValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FreeImageCodec[] = {  {&_swigt__p_Ogre__FreeImageCodec, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Frustum[] = {  {&_swigt__p_Ogre__Frustum, 0, 0, 0},  {&_swigt__p_Ogre__Camera, _p_Ogre__CameraTo_p_Ogre__Frustum, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__FrustumPlane[] = {  {&_swigt__p_Ogre__FrustumPlane, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuConstantDefinition[] = {  {&_swigt__p_Ogre__GpuConstantDefinition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuLogicalBufferStruct[] = {  {&_swigt__p_Ogre__GpuLogicalBufferStruct, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuLogicalIndexUse[] = {  {&_swigt__p_Ogre__GpuLogicalIndexUse, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuNamedConstants[] = {  {&_swigt__p_Ogre__GpuNamedConstants, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuNamedConstantsSerializer[] = {  {&_swigt__p_Ogre__GpuNamedConstantsSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgram[] = {  {&_swigt__p_Ogre__GpuProgram, 0, 0, 0},  {&_swigt__p_Ogre__HighLevelGpuProgram, _p_Ogre__HighLevelGpuProgramTo_p_Ogre__GpuProgram, 0, 0},  {&_swigt__p_Ogre__UnifiedHighLevelGpuProgram, _p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__GpuProgram, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgramManager[] = {  {&_swigt__p_Ogre__GpuProgramManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgramParameters[] = {  {&_swigt__p_Ogre__GpuProgramParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgramParameters__AutoConstantDefinition[] = {  {&_swigt__p_Ogre__GpuProgramParameters__AutoConstantDefinition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgramParameters__AutoConstantEntry[] = {  {&_swigt__p_Ogre__GpuProgramParameters__AutoConstantEntry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgramPtr[] = {  {&_swigt__p_Ogre__GpuProgramPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgramTranslator[] = {  {&_swigt__p_Ogre__GpuProgramTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuProgramUsage[] = {  {&_swigt__p_Ogre__GpuProgramUsage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuSharedParameters[] = {  {&_swigt__p_Ogre__GpuSharedParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__GpuSharedParametersUsage[] = {  {&_swigt__p_Ogre__GpuSharedParametersUsage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Grid2DPageStrategy[] = {  {&_swigt__p_Ogre__Grid2DPageStrategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Grid2DPageStrategyData[] = {  {&_swigt__p_Ogre__Grid2DPageStrategyData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Grid3DPageStrategy[] = {  {&_swigt__p_Ogre__Grid3DPageStrategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Grid3DPageStrategyData[] = {  {&_swigt__p_Ogre__Grid3DPageStrategyData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareBuffer[] = {  {&_swigt__p_Ogre__HardwareVertexBuffer, _p_Ogre__HardwareVertexBufferTo_p_Ogre__HardwareBuffer, 0, 0},  {&_swigt__p_Ogre__DefaultHardwareVertexBuffer, _p_Ogre__DefaultHardwareVertexBufferTo_p_Ogre__HardwareBuffer, 0, 0},  {&_swigt__p_Ogre__HardwareIndexBuffer, _p_Ogre__HardwareIndexBufferTo_p_Ogre__HardwareBuffer, 0, 0},  {&_swigt__p_Ogre__DefaultHardwareIndexBuffer, _p_Ogre__DefaultHardwareIndexBufferTo_p_Ogre__HardwareBuffer, 0, 0},  {&_swigt__p_Ogre__HardwarePixelBuffer, _p_Ogre__HardwarePixelBufferTo_p_Ogre__HardwareBuffer, 0, 0},  {&_swigt__p_Ogre__HardwareBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareBufferLicensee[] = {  {&_swigt__p_Ogre__HardwareBufferLicensee, 0, 0, 0},  {&_swigt__p_Ogre__TempBlendedBufferInfo, _p_Ogre__TempBlendedBufferInfoTo_p_Ogre__HardwareBufferLicensee, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareBufferManager[] = {  {&_swigt__p_Ogre__HardwareBufferManager, 0, 0, 0},  {&_swigt__p_Ogre__DefaultHardwareBufferManager, _p_Ogre__DefaultHardwareBufferManagerTo_p_Ogre__HardwareBufferManager, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareBufferManagerBase[] = {  {&_swigt__p_Ogre__HardwareBufferManager, _p_Ogre__HardwareBufferManagerTo_p_Ogre__HardwareBufferManagerBase, 0, 0},  {&_swigt__p_Ogre__DefaultHardwareBufferManager, _p_Ogre__DefaultHardwareBufferManagerTo_p_Ogre__HardwareBufferManagerBase, 0, 0},  {&_swigt__p_Ogre__HardwareBufferManagerBase, 0, 0, 0},  {&_swigt__p_Ogre__DefaultHardwareBufferManagerBase, _p_Ogre__DefaultHardwareBufferManagerBaseTo_p_Ogre__HardwareBufferManagerBase, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareIndexBuffer[] = {  {&_swigt__p_Ogre__HardwareIndexBuffer, 0, 0, 0},  {&_swigt__p_Ogre__DefaultHardwareIndexBuffer, _p_Ogre__DefaultHardwareIndexBufferTo_p_Ogre__HardwareIndexBuffer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareIndexBufferSharedPtr[] = {  {&_swigt__p_Ogre__HardwareIndexBufferSharedPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareOcclusionQuery[] = {  {&_swigt__p_Ogre__HardwareOcclusionQuery, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwarePixelBuffer[] = {  {&_swigt__p_Ogre__HardwarePixelBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwarePixelBufferSharedPtr[] = {  {&_swigt__p_Ogre__HardwarePixelBufferSharedPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareVertexBuffer[] = {  {&_swigt__p_Ogre__HardwareVertexBuffer, 0, 0, 0},  {&_swigt__p_Ogre__DefaultHardwareVertexBuffer, _p_Ogre__DefaultHardwareVertexBufferTo_p_Ogre__HardwareVertexBuffer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HardwareVertexBufferSharedPtr[] = {  {&_swigt__p_Ogre__HardwareVertexBufferSharedPtr, 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__HighLevelGpuProgram[] = {  {&_swigt__p_Ogre__HighLevelGpuProgram, 0, 0, 0},  {&_swigt__p_Ogre__UnifiedHighLevelGpuProgram, _p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__HighLevelGpuProgram, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UnifiedHighLevelGpuProgramFactory[] = {{&_swigt__p_Ogre__UnifiedHighLevelGpuProgramFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HighLevelGpuProgramFactory[] = {  {&_swigt__p_Ogre__HighLevelGpuProgramFactory, 0, 0, 0},  {&_swigt__p_Ogre__UnifiedHighLevelGpuProgramFactory, _p_Ogre__UnifiedHighLevelGpuProgramFactoryTo_p_Ogre__HighLevelGpuProgramFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HighLevelGpuProgramManager[] = {  {&_swigt__p_Ogre__HighLevelGpuProgramManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__HighLevelGpuProgramPtr[] = {  {&_swigt__p_Ogre__HighLevelGpuProgramPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__IOException[] = {  {&_swigt__p_Ogre__IOException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__IlluminationPass[] = {  {&_swigt__p_Ogre__IlluminationPass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Image[] = {  {&_swigt__p_Ogre__Image, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ImageCodec[] = {  {&_swigt__p_Ogre__ImageCodec, 0, 0, 0},  {&_swigt__p_Ogre__DDSCodec, _p_Ogre__DDSCodecTo_p_Ogre__ImageCodec, 0, 0},  {&_swigt__p_Ogre__FreeImageCodec, _p_Ogre__FreeImageCodecTo_p_Ogre__ImageCodec, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ImportAbstractNode[] = {  {&_swigt__p_Ogre__ImportAbstractNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__IndexData[] = {  {&_swigt__p_Ogre__IndexData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstanceBatch[] = {  {&_swigt__p_Ogre__InstanceBatchHW, _p_Ogre__InstanceBatchHWTo_p_Ogre__InstanceBatch, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW_VTF, _p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__InstanceBatch, 0, 0},  {&_swigt__p_Ogre__InstanceBatchShader, _p_Ogre__InstanceBatchShaderTo_p_Ogre__InstanceBatch, 0, 0},  {&_swigt__p_Ogre__InstanceBatch, 0, 0, 0},  {&_swigt__p_Ogre__BaseInstanceBatchVTF, _p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__InstanceBatch, 0, 0},  {&_swigt__p_Ogre__InstanceBatchVTF, _p_Ogre__InstanceBatchVTFTo_p_Ogre__InstanceBatch, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstanceBatchHW[] = {  {&_swigt__p_Ogre__InstanceBatchHW, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstanceBatchHW_VTF[] = {  {&_swigt__p_Ogre__InstanceBatchHW_VTF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstanceBatchShader[] = {  {&_swigt__p_Ogre__InstanceBatchShader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstanceBatchVTF[] = {  {&_swigt__p_Ogre__InstanceBatchVTF, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstanceManager[] = {  {&_swigt__p_Ogre__InstanceManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstancedEntity[] = {  {&_swigt__p_Ogre__InstancedEntity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstancedGeometry[] = {  {&_swigt__p_Ogre__InstancedGeometry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InstancedGeometry__BatchInstanceIterator[] = {  {&_swigt__p_Ogre__InstancedGeometry__BatchInstanceIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InternalErrorException[] = {  {&_swigt__p_Ogre__InternalErrorException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__IntersectionSceneQuery[] = {  {&_swigt__p_Ogre__IntersectionSceneQuery, 0, 0, 0},  {&_swigt__p_Ogre__DefaultIntersectionSceneQuery, _p_Ogre__DefaultIntersectionSceneQueryTo_p_Ogre__IntersectionSceneQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__IntersectionSceneQueryListener[] = {  {&_swigt__p_Ogre__IntersectionSceneQueryListener, 0, 0, 0},  {&_swigt__p_Ogre__IntersectionSceneQuery, _p_Ogre__IntersectionSceneQueryTo_p_Ogre__IntersectionSceneQueryListener, 0, 0},  {&_swigt__p_Ogre__DefaultIntersectionSceneQuery, _p_Ogre__DefaultIntersectionSceneQueryTo_p_Ogre__IntersectionSceneQueryListener, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__IntersectionSceneQueryResult[] = {  {&_swigt__p_Ogre__IntersectionSceneQueryResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InvalidParametersException[] = {  {&_swigt__p_Ogre__InvalidParametersException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__InvalidStateException[] = {  {&_swigt__p_Ogre__InvalidStateException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ItemIdentityException[] = {  {&_swigt__p_Ogre__ItemIdentityException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__KeyFrame[] = {  {&_swigt__p_Ogre__KeyFrame, 0, 0, 0},  {&_swigt__p_Ogre__NumericKeyFrame, _p_Ogre__NumericKeyFrameTo_p_Ogre__KeyFrame, 0, 0},  {&_swigt__p_Ogre__TransformKeyFrame, _p_Ogre__TransformKeyFrameTo_p_Ogre__KeyFrame, 0, 0},  {&_swigt__p_Ogre__VertexMorphKeyFrame, _p_Ogre__VertexMorphKeyFrameTo_p_Ogre__KeyFrame, 0, 0},  {&_swigt__p_Ogre__VertexPoseKeyFrame, _p_Ogre__VertexPoseKeyFrameTo_p_Ogre__KeyFrame, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LayerBlendModeEx[] = {  {&_swigt__p_Ogre__LayerBlendModeEx, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LiSPSMShadowCameraSetup[] = {  {&_swigt__p_Ogre__LiSPSMShadowCameraSetup, 0, 0, 0},  {&_swigt__p_Ogre__PSSMShadowCameraSetup, _p_Ogre__PSSMShadowCameraSetupTo_p_Ogre__LiSPSMShadowCameraSetup, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Light[] = {  {&_swigt__p_Ogre__Light, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LightFactory[] = {  {&_swigt__p_Ogre__LightFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LinkedSkeletonAnimationSource[] = {  {&_swigt__p_Ogre__LinkedSkeletonAnimationSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LodListener[] = {  {&_swigt__p_Ogre__LodListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LodStrategy[] = {  {&_swigt__p_Ogre__LodStrategy, 0, 0, 0},  {&_swigt__p_Ogre__DistanceLodStrategy, _p_Ogre__DistanceLodStrategyTo_p_Ogre__LodStrategy, 0, 0},  {&_swigt__p_Ogre__PixelCountLodStrategy, _p_Ogre__PixelCountLodStrategyTo_p_Ogre__LodStrategy, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LodStrategyManager[] = {  {&_swigt__p_Ogre__LodStrategyManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Log[] = {  {&_swigt__p_Ogre__Log, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LogListener[] = {  {&_swigt__p_Ogre__LogListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__LogManager[] = {  {&_swigt__p_Ogre__LogManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Log__Stream[] = {  {&_swigt__p_Ogre__Log__Stream, 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__ManualObjectFactory[] = {  {&_swigt__p_Ogre__ManualObjectFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ManualObject__ManualObjectSection[] = {  {&_swigt__p_Ogre__ManualObject__ManualObjectSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ManualResourceLoader[] = {  {&_swigt__p_Ogre__Font, _p_Ogre__FontTo_p_Ogre__ManualResourceLoader, 0, 0},  {&_swigt__p_Ogre__ManualResourceLoader, 0, 0, 0},  {&_swigt__p_Ogre__MeshManager, _p_Ogre__MeshManagerTo_p_Ogre__ManualResourceLoader, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_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_t[] = {  {&_swigt__p_Ogre__MapIteratorT_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_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Material[] = {  {&_swigt__p_Ogre__Material, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialManager[] = {  {&_swigt__p_Ogre__MaterialManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialManager__Listener[] = {  {&_swigt__p_Ogre__MaterialManager__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialPtr[] = {  {&_swigt__p_Ogre__MaterialPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialScriptContext[] = {  {&_swigt__p_Ogre__MaterialScriptContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialScriptProgramDefinition[] = {  {&_swigt__p_Ogre__MaterialScriptProgramDefinition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialSerializer[] = {  {&_swigt__p_Ogre__MaterialSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialSerializer__Listener[] = {  {&_swigt__p_Ogre__MaterialSerializer__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MaterialTranslator[] = {  {&_swigt__p_Ogre__MaterialTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Math[] = {  {&_swigt__p_Ogre__Math, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Matrix3[] = {  {&_swigt__p_Ogre__Matrix3, 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__MemoryDataStream[] = {  {&_swigt__p_Ogre__MemoryDataStream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Mesh[] = {  {&_swigt__p_Ogre__Mesh, 0, 0, 0},  {&_swigt__p_Ogre__PatchMesh, _p_Ogre__PatchMeshTo_p_Ogre__Mesh, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MeshLodUsage[] = {  {&_swigt__p_Ogre__MeshLodUsage, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MeshManager[] = {  {&_swigt__p_Ogre__MeshManager, 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__MeshSerializer[] = {  {&_swigt__p_Ogre__MeshSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MeshSerializerListener[] = {  {&_swigt__p_Ogre__MeshSerializerListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MovableObject[] = {  {&_swigt__p_Ogre__InstanceBatchVTF, _p_Ogre__InstanceBatchVTFTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__BaseInstanceBatchVTF, _p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__ManualObject, _p_Ogre__ManualObjectTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__Camera, _p_Ogre__CameraTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__BillboardChain, _p_Ogre__BillboardChainTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__SimpleRenderable, _p_Ogre__SimpleRenderableTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__WireBoundingBox, _p_Ogre__WireBoundingBoxTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__Entity, _p_Ogre__EntityTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__ParticleSystem, _p_Ogre__ParticleSystemTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW, _p_Ogre__InstanceBatchHWTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW_VTF, _p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__MovablePlane, _p_Ogre__MovablePlaneTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__InstancedEntity, _p_Ogre__InstancedEntityTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__MovableObject, 0, 0, 0},  {&_swigt__p_Ogre__Light, _p_Ogre__LightTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__BillboardSet, _p_Ogre__BillboardSetTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatch, _p_Ogre__InstanceBatchTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__InstanceBatchShader, _p_Ogre__InstanceBatchShaderTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__Frustum, _p_Ogre__FrustumTo_p_Ogre__MovableObject, 0, 0},  {&_swigt__p_Ogre__RibbonTrail, _p_Ogre__RibbonTrailTo_p_Ogre__MovableObject, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MovableObjectFactory[] = {  {&_swigt__p_Ogre__MovableObjectFactory, 0, 0, 0},  {&_swigt__p_Ogre__LightFactory, _p_Ogre__LightFactoryTo_p_Ogre__MovableObjectFactory, 0, 0},  {&_swigt__p_Ogre__BillboardChainFactory, _p_Ogre__BillboardChainFactoryTo_p_Ogre__MovableObjectFactory, 0, 0},  {&_swigt__p_Ogre__BillboardSetFactory, _p_Ogre__BillboardSetFactoryTo_p_Ogre__MovableObjectFactory, 0, 0},  {&_swigt__p_Ogre__EntityFactory, _p_Ogre__EntityFactoryTo_p_Ogre__MovableObjectFactory, 0, 0},  {&_swigt__p_Ogre__ManualObjectFactory, _p_Ogre__ManualObjectFactoryTo_p_Ogre__MovableObjectFactory, 0, 0},  {&_swigt__p_Ogre__ParticleSystemFactory, _p_Ogre__ParticleSystemFactoryTo_p_Ogre__MovableObjectFactory, 0, 0},  {&_swigt__p_Ogre__RibbonTrailFactory, _p_Ogre__RibbonTrailFactoryTo_p_Ogre__MovableObjectFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MovableObjectLodChangedEvent[] = {  {&_swigt__p_Ogre__MovableObjectLodChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__MovableObject__Listener[] = {  {&_swigt__p_Ogre__MovableObject__Listener, 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__MultiRenderTarget[] = {  {&_swigt__p_Ogre__MultiRenderTarget, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__NameGenerator[] = {  {&_swigt__p_Ogre__NameGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__NedPoolingImpl[] = {  {&_swigt__p_Ogre__NedPoolingImpl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__NedPoolingPolicy[] = {  {&_swigt__p_Ogre__NedPoolingPolicy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Node[] = {  {&_swigt__p_Ogre__TagPoint, _p_Ogre__TagPointTo_p_Ogre__Node, 0, 0},  {&_swigt__p_Ogre__SceneNode, _p_Ogre__SceneNodeTo_p_Ogre__Node, 0, 0},  {&_swigt__p_Ogre__Node, 0, 0, 0},  {&_swigt__p_Ogre__Bone, _p_Ogre__BoneTo_p_Ogre__Node, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__NodeAnimationTrack[] = {  {&_swigt__p_Ogre__NodeAnimationTrack, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Node__DebugRenderable[] = {  {&_swigt__p_Ogre__Node__DebugRenderable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Node__Listener[] = {  {&_swigt__p_Ogre__Node__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__NumericAnimationTrack[] = {  {&_swigt__p_Ogre__NumericAnimationTrack, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__NumericKeyFrame[] = {  {&_swigt__p_Ogre__NumericKeyFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ObjectAbstractNode[] = {  {&_swigt__p_Ogre__ObjectAbstractNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OptimisedUtil[] = {  {&_swigt__p_Ogre__OptimisedUtil, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Overlay[] = {  {&_swigt__p_Ogre__Overlay, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayContainer[] = {  {&_swigt__p_Ogre__PanelOverlayElement, _p_Ogre__PanelOverlayElementTo_p_Ogre__OverlayContainer, 0, 0},  {&_swigt__p_Ogre__BorderPanelOverlayElement, _p_Ogre__BorderPanelOverlayElementTo_p_Ogre__OverlayContainer, 0, 0},  {&_swigt__p_Ogre__OverlayContainer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElement[] = {  {&_swigt__p_Ogre__OverlayElement, 0, 0, 0},  {&_swigt__p_Ogre__PanelOverlayElement, _p_Ogre__PanelOverlayElementTo_p_Ogre__OverlayElement, 0, 0},  {&_swigt__p_Ogre__BorderPanelOverlayElement, _p_Ogre__BorderPanelOverlayElementTo_p_Ogre__OverlayElement, 0, 0},  {&_swigt__p_Ogre__TextAreaOverlayElement, _p_Ogre__TextAreaOverlayElementTo_p_Ogre__OverlayElement, 0, 0},  {&_swigt__p_Ogre__OverlayContainer, _p_Ogre__OverlayContainerTo_p_Ogre__OverlayElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdCaption[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdCaption, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdHeight[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdHeight, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdHorizontalAlign[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdHorizontalAlign, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdLeft[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdLeft, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdMaterial[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdMaterial, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdMetricsMode[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdMetricsMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdTop[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdTop, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdVerticalAlign[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdVerticalAlign, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdVisible[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdVisible, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementCommands__CmdWidth[] = {  {&_swigt__p_Ogre__OverlayElementCommands__CmdWidth, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayElementFactory[] = {  {&_swigt__p_Ogre__OverlayElementFactory, 0, 0, 0},  {&_swigt__p_Ogre__PanelOverlayElementFactory, _p_Ogre__PanelOverlayElementFactoryTo_p_Ogre__OverlayElementFactory, 0, 0},  {&_swigt__p_Ogre__BorderPanelOverlayElementFactory, _p_Ogre__BorderPanelOverlayElementFactoryTo_p_Ogre__OverlayElementFactory, 0, 0},  {&_swigt__p_Ogre__TextAreaOverlayElementFactory, _p_Ogre__TextAreaOverlayElementFactoryTo_p_Ogre__OverlayElementFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__OverlayManager[] = {  {&_swigt__p_Ogre__OverlayManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PSSMShadowCameraSetup[] = {  {&_swigt__p_Ogre__PSSMShadowCameraSetup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Page[] = {  {&_swigt__p_Ogre__Page, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageContent[] = {  {&_swigt__p_Ogre__PageContent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageContentCollection[] = {  {&_swigt__p_Ogre__PageContentCollection, 0, 0, 0},  {&_swigt__p_Ogre__SimplePageContentCollection, _p_Ogre__SimplePageContentCollectionTo_p_Ogre__PageContentCollection, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageContentCollectionFactory[] = {  {&_swigt__p_Ogre__PageContentCollectionFactory, 0, 0, 0},  {&_swigt__p_Ogre__SimplePageContentCollectionFactory, _p_Ogre__SimplePageContentCollectionFactoryTo_p_Ogre__PageContentCollectionFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageContentFactory[] = {  {&_swigt__p_Ogre__PageContentFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageManager[] = {  {&_swigt__p_Ogre__PageManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageProvider[] = {  {&_swigt__p_Ogre__PageProvider, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageStrategy[] = {  {&_swigt__p_Ogre__PageStrategy, 0, 0, 0},  {&_swigt__p_Ogre__Grid2DPageStrategy, _p_Ogre__Grid2DPageStrategyTo_p_Ogre__PageStrategy, 0, 0},  {&_swigt__p_Ogre__Grid3DPageStrategy, _p_Ogre__Grid3DPageStrategyTo_p_Ogre__PageStrategy, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PageStrategyData[] = {  {&_swigt__p_Ogre__PageStrategyData, 0, 0, 0},  {&_swigt__p_Ogre__Grid2DPageStrategyData, _p_Ogre__Grid2DPageStrategyDataTo_p_Ogre__PageStrategyData, 0, 0},  {&_swigt__p_Ogre__Grid3DPageStrategyData, _p_Ogre__Grid3DPageStrategyDataTo_p_Ogre__PageStrategyData, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PagedWorld[] = {  {&_swigt__p_Ogre__PagedWorld, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PagedWorldSection[] = {  {&_swigt__p_Ogre__PagedWorldSection, 0, 0, 0},  {&_swigt__p_Ogre__TerrainPagedWorldSection, _p_Ogre__TerrainPagedWorldSectionTo_p_Ogre__PagedWorldSection, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PagedWorldSectionFactory[] = {  {&_swigt__p_Ogre__PagedWorldSectionFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PanelOverlayElement[] = {  {&_swigt__p_Ogre__PanelOverlayElement, 0, 0, 0},  {&_swigt__p_Ogre__BorderPanelOverlayElement, _p_Ogre__BorderPanelOverlayElementTo_p_Ogre__PanelOverlayElement, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PanelOverlayElementFactory[] = {  {&_swigt__p_Ogre__PanelOverlayElementFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParamCommand[] = {  {&_swigt__p_Ogre__EmitterCommands__CmdTTL, _p_Ogre__EmitterCommands__CmdTTLTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdDirection, _p_Ogre__EmitterCommands__CmdDirectionTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdColour, _p_Ogre__EmitterCommands__CmdColourTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdHorizontalAlign, _p_Ogre__OverlayElementCommands__CmdHorizontalAlignTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdCaption, _p_Ogre__OverlayElementCommands__CmdCaptionTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdColourRangeEnd, _p_Ogre__EmitterCommands__CmdColourRangeEndTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdColourRangeStart, _p_Ogre__EmitterCommands__CmdColourRangeStartTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdAngle, _p_Ogre__EmitterCommands__CmdAngleTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdMaterial, _p_Ogre__OverlayElementCommands__CmdMaterialTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdHeight, _p_Ogre__OverlayElementCommands__CmdHeightTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdVelocity, _p_Ogre__EmitterCommands__CmdVelocityTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMinVelocity, _p_Ogre__EmitterCommands__CmdMinVelocityTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdLeft, _p_Ogre__OverlayElementCommands__CmdLeftTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMaxVelocity, _p_Ogre__EmitterCommands__CmdMaxVelocityTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdPosition, _p_Ogre__EmitterCommands__CmdPositionTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdMetricsMode, _p_Ogre__OverlayElementCommands__CmdMetricsModeTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMaxTTL, _p_Ogre__EmitterCommands__CmdMaxTTLTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdUp, _p_Ogre__EmitterCommands__CmdUpTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__ParamCommand, 0, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdVerticalAlign, _p_Ogre__OverlayElementCommands__CmdVerticalAlignTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdEmissionRate, _p_Ogre__EmitterCommands__CmdEmissionRateTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdName, _p_Ogre__EmitterCommands__CmdNameTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdEmittedEmitter, _p_Ogre__EmitterCommands__CmdEmittedEmitterTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdTop, _p_Ogre__OverlayElementCommands__CmdTopTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdVisible, _p_Ogre__OverlayElementCommands__CmdVisibleTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__OverlayElementCommands__CmdWidth, _p_Ogre__OverlayElementCommands__CmdWidthTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMinTTL, _p_Ogre__EmitterCommands__CmdMinTTLTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdDuration, _p_Ogre__EmitterCommands__CmdDurationTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMinDuration, _p_Ogre__EmitterCommands__CmdMinDurationTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMaxDuration, _p_Ogre__EmitterCommands__CmdMaxDurationTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdRepeatDelay, _p_Ogre__EmitterCommands__CmdRepeatDelayTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMinRepeatDelay, _p_Ogre__EmitterCommands__CmdMinRepeatDelayTo_p_Ogre__ParamCommand, 0, 0},  {&_swigt__p_Ogre__EmitterCommands__CmdMaxRepeatDelay, _p_Ogre__EmitterCommands__CmdMaxRepeatDelayTo_p_Ogre__ParamCommand, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParamDictionary[] = {  {&_swigt__p_Ogre__ParamDictionary, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParameterDef[] = {  {&_swigt__p_Ogre__ParameterDef, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Particle[] = {  {&_swigt__p_Ogre__ParticleEmitter, _p_Ogre__ParticleEmitterTo_p_Ogre__Particle, 0, 0},  {&_swigt__p_Ogre__Particle, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleAffector[] = {  {&_swigt__p_Ogre__ParticleAffector, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleAffectorFactory[] = {  {&_swigt__p_Ogre__ParticleAffectorFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleAffectorTranslator[] = {  {&_swigt__p_Ogre__ParticleAffectorTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleEmitter[] = {  {&_swigt__p_Ogre__ParticleEmitter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleEmitterFactory[] = {  {&_swigt__p_Ogre__ParticleEmitterFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleEmitterTranslator[] = {  {&_swigt__p_Ogre__ParticleEmitterTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleIterator[] = {  {&_swigt__p_Ogre__ParticleIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleSystem[] = {  {&_swigt__p_Ogre__ParticleSystem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleSystemFactory[] = {  {&_swigt__p_Ogre__ParticleSystemFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleSystemManager[] = {  {&_swigt__p_Ogre__ParticleSystemManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleSystemRenderer[] = {  {&_swigt__p_Ogre__ParticleSystemRenderer, 0, 0, 0},  {&_swigt__p_Ogre__BillboardParticleRenderer, _p_Ogre__BillboardParticleRendererTo_p_Ogre__ParticleSystemRenderer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleSystemRendererFactory[] = {  {&_swigt__p_Ogre__ParticleSystemRendererFactory, 0, 0, 0},  {&_swigt__p_Ogre__BillboardParticleRendererFactory, _p_Ogre__BillboardParticleRendererFactoryTo_p_Ogre__ParticleSystemRendererFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleSystemTranslator[] = {  {&_swigt__p_Ogre__ParticleSystemTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ParticleVisualData[] = {  {&_swigt__p_Ogre__ParticleVisualData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Pass[] = {  {&_swigt__p_Ogre__Pass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PassTranslator[] = {  {&_swigt__p_Ogre__PassTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Pass__HashFunc[] = {  {&_swigt__p_Ogre__Pass__HashFunc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PassthroughControllerFunction[] = {  {&_swigt__p_Ogre__PassthroughControllerFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PatchMesh[] = {  {&_swigt__p_Ogre__PatchMesh, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PatchMeshPtr[] = {  {&_swigt__p_Ogre__PatchMeshPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PatchSurface[] = {  {&_swigt__p_Ogre__PatchSurface, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PixelBox[] = {  {&_swigt__p_Ogre__PixelBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PixelCountLodStrategy[] = {  {&_swigt__p_Ogre__PixelCountLodStrategy, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PixelUtil[] = {  {&_swigt__p_Ogre__PixelUtil, 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},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PlaneBoundedVolume[] = {  {&_swigt__p_Ogre__PlaneBoundedVolume, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PlaneBoundedVolumeListSceneQuery[] = {  {&_swigt__p_Ogre__PlaneBoundedVolumeListSceneQuery, 0, 0, 0},  {&_swigt__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery, _p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__PlaneBoundedVolumeListSceneQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PlaneOptimalShadowCameraSetup[] = {  {&_swigt__p_Ogre__PlaneOptimalShadowCameraSetup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PlatformInformation[] = {  {&_swigt__p_Ogre__PlatformInformation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Plugin[] = {  {&_swigt__p_Ogre__Plugin, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Polygon[] = {  {&_swigt__p_Ogre__Polygon, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Pose[] = {  {&_swigt__p_Ogre__Pose, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PreApplyTextureAliasesScriptCompilerEvent[] = {  {&_swigt__p_Ogre__PreApplyTextureAliasesScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PrefabFactory[] = {  {&_swigt__p_Ogre__PrefabFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ProcessNameExclusionScriptCompilerEvent[] = {  {&_swigt__p_Ogre__ProcessNameExclusionScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ProcessResourceNameScriptCompilerEvent[] = {  {&_swigt__p_Ogre__ProcessResourceNameScriptCompilerEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Profile[] = {  {&_swigt__p_Ogre__Profile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Profiler[] = {  {&_swigt__p_Ogre__Profiler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__PropertyAbstractNode[] = {  {&_swigt__p_Ogre__PropertyAbstractNode, 0, 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__QueuedRenderableCollection[] = {  {&_swigt__p_Ogre__QueuedRenderableCollection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__QueuedRenderableVisitor[] = {  {&_swigt__p_Ogre__QueuedRenderableVisitor, 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__Ray[] = {  {&_swigt__p_Ogre__Ray, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RaySceneQuery[] = {  {&_swigt__p_Ogre__RaySceneQuery, 0, 0, 0},  {&_swigt__p_Ogre__DefaultRaySceneQuery, _p_Ogre__DefaultRaySceneQueryTo_p_Ogre__RaySceneQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RaySceneQueryListener[] = {  {&_swigt__p_Ogre__RaySceneQueryListener, 0, 0, 0},  {&_swigt__p_Ogre__RaySceneQuery, _p_Ogre__RaySceneQueryTo_p_Ogre__RaySceneQueryListener, 0, 0},  {&_swigt__p_Ogre__DefaultRaySceneQuery, _p_Ogre__DefaultRaySceneQueryTo_p_Ogre__RaySceneQueryListener, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RaySceneQueryResultEntry[] = {  {&_swigt__p_Ogre__RaySceneQueryResultEntry, 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__Rectangle2D[] = {  {&_swigt__p_Ogre__Rectangle2D, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RegionSceneQuery[] = {  {&_swigt__p_Ogre__RegionSceneQuery, 0, 0, 0},  {&_swigt__p_Ogre__AxisAlignedBoxSceneQuery, _p_Ogre__AxisAlignedBoxSceneQueryTo_p_Ogre__RegionSceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultAxisAlignedBoxSceneQuery, _p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__RegionSceneQuery, 0, 0},  {&_swigt__p_Ogre__SphereSceneQuery, _p_Ogre__SphereSceneQueryTo_p_Ogre__RegionSceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultSphereSceneQuery, _p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__RegionSceneQuery, 0, 0},  {&_swigt__p_Ogre__PlaneBoundedVolumeListSceneQuery, _p_Ogre__PlaneBoundedVolumeListSceneQueryTo_p_Ogre__RegionSceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery, _p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__RegionSceneQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderObjectListener[] = {  {&_swigt__p_Ogre__RenderObjectListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderOperation[] = {  {&_swigt__p_Ogre__RenderOperation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderPriorityGroup[] = {  {&_swigt__p_Ogre__RenderPriorityGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueue[] = {  {&_swigt__p_Ogre__RenderQueue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueueGroup[] = {  {&_swigt__p_Ogre__RenderQueueGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueueGroup__ConstPriorityMapIterator[] = {  {&_swigt__p_Ogre__RenderQueueGroup__ConstPriorityMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueueGroup__PriorityMapIterator[] = {  {&_swigt__p_Ogre__RenderQueueGroup__PriorityMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueueInvocation[] = {  {&_swigt__p_Ogre__RenderQueueInvocation, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueueInvocationSequence[] = {  {&_swigt__p_Ogre__RenderQueueInvocationSequence, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueueListener[] = {  {&_swigt__p_Ogre__RenderQueueListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderQueue__RenderableListener[] = {  {&_swigt__p_Ogre__RenderQueue__RenderableListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderSystem[] = {  {&_swigt__p_Ogre__RenderSystem, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderSystemCapabilities[] = {  {&_swigt__p_Ogre__RenderSystemCapabilities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderSystemCapabilitiesManager[] = {  {&_swigt__p_Ogre__RenderSystemCapabilitiesManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderSystemCapabilitiesSerializer[] = {  {&_swigt__p_Ogre__RenderSystemCapabilitiesSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderSystem__Listener[] = {  {&_swigt__p_Ogre__RenderSystem__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderSystem__RenderSystemContext[] = {  {&_swigt__p_Ogre__RenderSystem__RenderSystemContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderTarget[] = {  {&_swigt__p_Ogre__RenderTarget, 0, 0, 0},  {&_swigt__p_Ogre__MultiRenderTarget, _p_Ogre__MultiRenderTargetTo_p_Ogre__RenderTarget, 0, 0},  {&_swigt__p_Ogre__RenderWindow, _p_Ogre__RenderWindowTo_p_Ogre__RenderTarget, 0, 0},  {&_swigt__p_Ogre__RenderTexture, _p_Ogre__RenderTextureTo_p_Ogre__RenderTarget, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderTargetEvent[] = {  {&_swigt__p_Ogre__RenderTargetEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderTargetListener[] = {  {&_swigt__p_Ogre__RenderTargetListener, 0, 0, 0},  {&_swigt__p_Ogre__CompositorChain, _p_Ogre__CompositorChainTo_p_Ogre__RenderTargetListener, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderTargetViewportEvent[] = {  {&_swigt__p_Ogre__RenderTargetViewportEvent, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderTarget__FrameStats[] = {  {&_swigt__p_Ogre__RenderTarget__FrameStats, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderTarget__Impl[] = {  {&_swigt__p_Ogre__RenderTarget__Impl, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderTexture[] = {  {&_swigt__p_Ogre__RenderTexture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderToVertexBuffer[] = {  {&_swigt__p_Ogre__RenderToVertexBuffer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderWindow[] = {  {&_swigt__p_Ogre__RenderWindow, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderWindowDescription[] = {  {&_swigt__p_Ogre__RenderWindowDescription, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Renderable[] = {  {&_swigt__p_Ogre__InstanceBatchVTF, _p_Ogre__InstanceBatchVTFTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__BaseInstanceBatchVTF, _p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__Camera, _p_Ogre__CameraTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__BillboardChain, _p_Ogre__BillboardChainTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__BorderRenderable, _p_Ogre__BorderRenderableTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__ShadowRenderable, _p_Ogre__ShadowRenderableTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__SimpleRenderable, _p_Ogre__SimpleRenderableTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__Renderable, 0, 0, 0},  {&_swigt__p_Ogre__WireBoundingBox, _p_Ogre__WireBoundingBoxTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW, _p_Ogre__InstanceBatchHWTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW_VTF, _p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__OverlayContainer, _p_Ogre__OverlayContainerTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__SubEntity, _p_Ogre__SubEntityTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__PanelOverlayElement, _p_Ogre__PanelOverlayElementTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__BorderPanelOverlayElement, _p_Ogre__BorderPanelOverlayElementTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__BillboardSet, _p_Ogre__BillboardSetTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__InstanceBatch, _p_Ogre__InstanceBatchTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__InstanceBatchShader, _p_Ogre__InstanceBatchShaderTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__Frustum, _p_Ogre__FrustumTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__OverlayElement, _p_Ogre__OverlayElementTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__TextAreaOverlayElement, _p_Ogre__TextAreaOverlayElementTo_p_Ogre__Renderable, 0, 0},  {&_swigt__p_Ogre__RibbonTrail, _p_Ogre__RibbonTrailTo_p_Ogre__Renderable, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderablePass[] = {  {&_swigt__p_Ogre__RenderablePass, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Renderable__RenderSystemData[] = {  {&_swigt__p_Ogre__Renderable__RenderSystemData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Renderable__Visitor[] = {  {&_swigt__p_Ogre__Renderable__Visitor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RenderingAPIException[] = {  {&_swigt__p_Ogre__RenderingAPIException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Resource[] = {  {&_swigt__p_Ogre__GpuProgram, _p_Ogre__GpuProgramTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__HighLevelGpuProgram, _p_Ogre__HighLevelGpuProgramTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__UnifiedHighLevelGpuProgram, _p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__Compositor, _p_Ogre__CompositorTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__Resource, 0, 0, 0},  {&_swigt__p_Ogre__SkeletonInstance, _p_Ogre__SkeletonInstanceTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__Font, _p_Ogre__FontTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__Mesh, _p_Ogre__MeshTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__Material, _p_Ogre__MaterialTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__Texture, _p_Ogre__TextureTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__PatchMesh, _p_Ogre__PatchMeshTo_p_Ogre__Resource, 0, 0},  {&_swigt__p_Ogre__Skeleton, _p_Ogre__SkeletonTo_p_Ogre__Resource, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceBackgroundQueue[] = {  {&_swigt__p_Ogre__ResourceBackgroundQueue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceBackgroundQueue__Listener[] = {  {&_swigt__p_Ogre__ResourceBackgroundQueue__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceGroupListener[] = {  {&_swigt__p_Ogre__ResourceGroupListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceGroupManager[] = {  {&_swigt__p_Ogre__ResourceGroupManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceGroupManager__ResourceManagerIterator[] = {  {&_swigt__p_Ogre__ResourceGroupManager__ResourceManagerIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceLoadingListener[] = {  {&_swigt__p_Ogre__ResourceLoadingListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceManager[] = {  {&_swigt__p_Ogre__ResourceManager, 0, 0, 0},  {&_swigt__p_Ogre__MaterialManager, _p_Ogre__MaterialManagerTo_p_Ogre__ResourceManager, 0, 0},  {&_swigt__p_Ogre__TextureManager, _p_Ogre__TextureManagerTo_p_Ogre__ResourceManager, 0, 0},  {&_swigt__p_Ogre__CompositorManager, _p_Ogre__CompositorManagerTo_p_Ogre__ResourceManager, 0, 0},  {&_swigt__p_Ogre__FontManager, _p_Ogre__FontManagerTo_p_Ogre__ResourceManager, 0, 0},  {&_swigt__p_Ogre__GpuProgramManager, _p_Ogre__GpuProgramManagerTo_p_Ogre__ResourceManager, 0, 0},  {&_swigt__p_Ogre__HighLevelGpuProgramManager, _p_Ogre__HighLevelGpuProgramManagerTo_p_Ogre__ResourceManager, 0, 0},  {&_swigt__p_Ogre__MeshManager, _p_Ogre__MeshManagerTo_p_Ogre__ResourceManager, 0, 0},  {&_swigt__p_Ogre__SkeletonManager, _p_Ogre__SkeletonManagerTo_p_Ogre__ResourceManager, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceManager__ResourceMapIterator[] = {  {&_swigt__p_Ogre__ResourceManager__ResourceMapIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ResourceManager__ResourcePool[] = {  {&_swigt__p_Ogre__ResourceManager__ResourcePool, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Resource__Listener[] = {  {&_swigt__p_Ogre__Resource__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RibbonTrail[] = {  {&_swigt__p_Ogre__RibbonTrail, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RibbonTrailFactory[] = {  {&_swigt__p_Ogre__RibbonTrailFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Root[] = {  {&_swigt__p_Ogre__Root, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Root__MovableObjectFactoryIterator[] = {  {&_swigt__p_Ogre__Root__MovableObjectFactoryIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RotationalSpline[] = {  {&_swigt__p_Ogre__RotationalSpline, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__RuntimeAssertionException[] = {  {&_swigt__p_Ogre__RuntimeAssertionException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScaleControllerFunction[] = {  {&_swigt__p_Ogre__ScaleControllerFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager[] = {  {&_swigt__p_Ogre__SceneManager, 0, 0, 0},  {&_swigt__p_Ogre__DefaultSceneManager, _p_Ogre__DefaultSceneManagerTo_p_Ogre__SceneManager, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManagerEnumerator[] = {  {&_swigt__p_Ogre__SceneManagerEnumerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManagerEnumerator__MetaDataIterator[] = {  {&_swigt__p_Ogre__SceneManagerEnumerator__MetaDataIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManagerEnumerator__SceneManagerIterator[] = {  {&_swigt__p_Ogre__SceneManagerEnumerator__SceneManagerIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManagerFactory[] = {  {&_swigt__p_Ogre__SceneManagerFactory, 0, 0, 0},  {&_swigt__p_Ogre__DefaultSceneManagerFactory, _p_Ogre__DefaultSceneManagerFactoryTo_p_Ogre__SceneManagerFactory, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManagerMetaData[] = {  {&_swigt__p_Ogre__SceneManagerMetaData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__AnimationIterator[] = {  {&_swigt__p_Ogre__SceneManager__AnimationIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__CameraIterator[] = {  {&_swigt__p_Ogre__SceneManager__CameraIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__Listener[] = {  {&_swigt__p_Ogre__SceneManager__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__MovableObjectIterator[] = {  {&_swigt__p_Ogre__SceneManager__MovableObjectIterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__RenderContext[] = {  {&_swigt__p_Ogre__SceneManager__RenderContext, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor[] = {  {&_swigt__p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__SkyBoxGenParameters[] = {  {&_swigt__p_Ogre__SceneManager__SkyBoxGenParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__SkyDomeGenParameters[] = {  {&_swigt__p_Ogre__SceneManager__SkyDomeGenParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneManager__SkyPlaneGenParameters[] = {  {&_swigt__p_Ogre__SceneManager__SkyPlaneGenParameters, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneNode[] = {  {&_swigt__p_Ogre__SceneNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneQuery[] = {  {&_swigt__p_Ogre__SceneQuery, 0, 0, 0},  {&_swigt__p_Ogre__RegionSceneQuery, _p_Ogre__RegionSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__AxisAlignedBoxSceneQuery, _p_Ogre__AxisAlignedBoxSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultAxisAlignedBoxSceneQuery, _p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__SphereSceneQuery, _p_Ogre__SphereSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultSphereSceneQuery, _p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__PlaneBoundedVolumeListSceneQuery, _p_Ogre__PlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery, _p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__RaySceneQuery, _p_Ogre__RaySceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultRaySceneQuery, _p_Ogre__DefaultRaySceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__IntersectionSceneQuery, _p_Ogre__IntersectionSceneQueryTo_p_Ogre__SceneQuery, 0, 0},  {&_swigt__p_Ogre__DefaultIntersectionSceneQuery, _p_Ogre__DefaultIntersectionSceneQueryTo_p_Ogre__SceneQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneQueryListener[] = {  {&_swigt__p_Ogre__SceneQueryListener, 0, 0, 0},  {&_swigt__p_Ogre__RegionSceneQuery, _p_Ogre__RegionSceneQueryTo_p_Ogre__SceneQueryListener, 0, 0},  {&_swigt__p_Ogre__AxisAlignedBoxSceneQuery, _p_Ogre__AxisAlignedBoxSceneQueryTo_p_Ogre__SceneQueryListener, 0, 0},  {&_swigt__p_Ogre__DefaultAxisAlignedBoxSceneQuery, _p_Ogre__DefaultAxisAlignedBoxSceneQueryTo_p_Ogre__SceneQueryListener, 0, 0},  {&_swigt__p_Ogre__SphereSceneQuery, _p_Ogre__SphereSceneQueryTo_p_Ogre__SceneQueryListener, 0, 0},  {&_swigt__p_Ogre__DefaultSphereSceneQuery, _p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__SceneQueryListener, 0, 0},  {&_swigt__p_Ogre__PlaneBoundedVolumeListSceneQuery, _p_Ogre__PlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQueryListener, 0, 0},  {&_swigt__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery, _p_Ogre__DefaultPlaneBoundedVolumeListSceneQueryTo_p_Ogre__SceneQueryListener, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneQueryResult[] = {  {&_swigt__p_Ogre__SceneQueryResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SceneQuery__WorldFragment[] = {  {&_swigt__p_Ogre__SceneQuery__WorldFragment, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptCompiler[] = {  {&_swigt__p_Ogre__ScriptCompiler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptCompilerEvent[] = {  {&_swigt__p_Ogre__ScriptCompilerEvent, 0, 0, 0},  {&_swigt__p_Ogre__PreApplyTextureAliasesScriptCompilerEvent, _p_Ogre__PreApplyTextureAliasesScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__ProcessResourceNameScriptCompilerEvent, _p_Ogre__ProcessResourceNameScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__ProcessNameExclusionScriptCompilerEvent, _p_Ogre__ProcessNameExclusionScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__CreateMaterialScriptCompilerEvent, _p_Ogre__CreateMaterialScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__CreateGpuProgramScriptCompilerEvent, _p_Ogre__CreateGpuProgramScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, _p_Ogre__CreateHighLevelGpuProgramScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__CreateGpuSharedParametersScriptCompilerEvent, _p_Ogre__CreateGpuSharedParametersScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__CreateParticleSystemScriptCompilerEvent, _p_Ogre__CreateParticleSystemScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},  {&_swigt__p_Ogre__CreateCompositorScriptCompilerEvent, _p_Ogre__CreateCompositorScriptCompilerEventTo_p_Ogre__ScriptCompilerEvent, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptCompilerListener[] = {  {&_swigt__p_Ogre__ScriptCompilerListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptCompilerManager[] = {  {&_swigt__p_Ogre__ScriptCompilerManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptLexer[] = {  {&_swigt__p_Ogre__ScriptLexer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptLoader[] = {  {&_swigt__p_Ogre__ScriptLoader, 0, 0, 0},  {&_swigt__p_Ogre__ResourceManager, _p_Ogre__ResourceManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__MaterialManager, _p_Ogre__MaterialManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__TextureManager, _p_Ogre__TextureManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__CompositorManager, _p_Ogre__CompositorManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__FontManager, _p_Ogre__FontManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__GpuProgramManager, _p_Ogre__GpuProgramManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__HighLevelGpuProgramManager, _p_Ogre__HighLevelGpuProgramManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__MeshManager, _p_Ogre__MeshManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__SkeletonManager, _p_Ogre__SkeletonManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__OverlayManager, _p_Ogre__OverlayManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__ScriptCompilerManager, _p_Ogre__ScriptCompilerManagerTo_p_Ogre__ScriptLoader, 0, 0},  {&_swigt__p_Ogre__ParticleSystemManager, _p_Ogre__ParticleSystemManagerTo_p_Ogre__ScriptLoader, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptParser[] = {  {&_swigt__p_Ogre__ScriptParser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptToken[] = {  {&_swigt__p_Ogre__ScriptToken, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptTranslator[] = {  {&_swigt__p_Ogre__CompositionPassTranslator, _p_Ogre__CompositionPassTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__CompositionTargetPassTranslator, _p_Ogre__CompositionTargetPassTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__CompositionTechniqueTranslator, _p_Ogre__CompositionTechniqueTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__CompositorTranslator, _p_Ogre__CompositorTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__ParticleAffectorTranslator, _p_Ogre__ParticleAffectorTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__ParticleEmitterTranslator, _p_Ogre__ParticleEmitterTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__ParticleSystemTranslator, _p_Ogre__ParticleSystemTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__SharedParamsTranslator, _p_Ogre__SharedParamsTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__GpuProgramTranslator, _p_Ogre__GpuProgramTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__TextureSourceTranslator, _p_Ogre__TextureSourceTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__TextureUnitTranslator, _p_Ogre__TextureUnitTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__PassTranslator, _p_Ogre__PassTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__TechniqueTranslator, _p_Ogre__TechniqueTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},  {&_swigt__p_Ogre__ScriptTranslator, 0, 0, 0},  {&_swigt__p_Ogre__MaterialTranslator, _p_Ogre__MaterialTranslatorTo_p_Ogre__ScriptTranslator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ScriptTranslatorManager[] = {  {&_swigt__p_Ogre__ScriptTranslatorManager, 0, 0, 0},  {&_swigt__p_Ogre__BuiltinScriptTranslatorManager, _p_Ogre__BuiltinScriptTranslatorManagerTo_p_Ogre__ScriptTranslatorManager, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Serializer[] = {  {&_swigt__p_Ogre__Serializer, 0, 0, 0},  {&_swigt__p_Ogre__GpuNamedConstantsSerializer, _p_Ogre__GpuNamedConstantsSerializerTo_p_Ogre__Serializer, 0, 0},  {&_swigt__p_Ogre__MeshSerializer, _p_Ogre__MeshSerializerTo_p_Ogre__Serializer, 0, 0},  {&_swigt__p_Ogre__SkeletonSerializer, _p_Ogre__SkeletonSerializerTo_p_Ogre__Serializer, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ShadowCameraSetup[] = {  {&_swigt__p_Ogre__ShadowCameraSetup, 0, 0, 0},  {&_swigt__p_Ogre__DefaultShadowCameraSetup, _p_Ogre__DefaultShadowCameraSetupTo_p_Ogre__ShadowCameraSetup, 0, 0},  {&_swigt__p_Ogre__FocusedShadowCameraSetup, _p_Ogre__FocusedShadowCameraSetupTo_p_Ogre__ShadowCameraSetup, 0, 0},  {&_swigt__p_Ogre__LiSPSMShadowCameraSetup, _p_Ogre__LiSPSMShadowCameraSetupTo_p_Ogre__ShadowCameraSetup, 0, 0},  {&_swigt__p_Ogre__PSSMShadowCameraSetup, _p_Ogre__PSSMShadowCameraSetupTo_p_Ogre__ShadowCameraSetup, 0, 0},  {&_swigt__p_Ogre__PlaneOptimalShadowCameraSetup, _p_Ogre__PlaneOptimalShadowCameraSetupTo_p_Ogre__ShadowCameraSetup, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ShadowCaster[] = {  {&_swigt__p_Ogre__InstanceBatchVTF, _p_Ogre__InstanceBatchVTFTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__BaseInstanceBatchVTF, _p_Ogre__BaseInstanceBatchVTFTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__ManualObject, _p_Ogre__ManualObjectTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__Camera, _p_Ogre__CameraTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__BillboardChain, _p_Ogre__BillboardChainTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__SimpleRenderable, _p_Ogre__SimpleRenderableTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__WireBoundingBox, _p_Ogre__WireBoundingBoxTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__ShadowCaster, 0, 0, 0},  {&_swigt__p_Ogre__Entity, _p_Ogre__EntityTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__ParticleSystem, _p_Ogre__ParticleSystemTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW, _p_Ogre__InstanceBatchHWTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__InstanceBatchHW_VTF, _p_Ogre__InstanceBatchHW_VTFTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__MovablePlane, _p_Ogre__MovablePlaneTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__InstancedEntity, _p_Ogre__InstancedEntityTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__Light, _p_Ogre__LightTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__BillboardSet, _p_Ogre__BillboardSetTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__InstanceBatch, _p_Ogre__InstanceBatchTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__InstanceBatchShader, _p_Ogre__InstanceBatchShaderTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__MovableObject, _p_Ogre__MovableObjectTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__Frustum, _p_Ogre__FrustumTo_p_Ogre__ShadowCaster, 0, 0},  {&_swigt__p_Ogre__RibbonTrail, _p_Ogre__RibbonTrailTo_p_Ogre__ShadowCaster, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ShadowRenderable[] = {  {&_swigt__p_Ogre__ShadowRenderable, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ShadowTextureConfig[] = {  {&_swigt__p_Ogre__ShadowTextureConfig, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ShadowTextureManager[] = {  {&_swigt__p_Ogre__ShadowTextureManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ShadowVolumeExtrudeProgram[] = {  {&_swigt__p_Ogre__ShadowVolumeExtrudeProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SharedParamsTranslator[] = {  {&_swigt__p_Ogre__SharedParamsTranslator, 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__CodecData_t[] = {  {&_swigt__p_Ogre__SharedPtrT_Ogre__CodecData_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__Material_t[] = {  {&_swigt__p_Ogre__MaterialPtr, _p_Ogre__MaterialPtrTo_p_Ogre__SharedPtrT_Ogre__Material_t, 0, 0},  {&_swigt__p_Ogre__SharedPtrT_Ogre__Material_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__Mesh_t[] = {  {&_swigt__p_Ogre__MeshPtr, _p_Ogre__MeshPtrTo_p_Ogre__SharedPtrT_Ogre__Mesh_t, 0, 0},  {&_swigt__p_Ogre__SharedPtrT_Ogre__Mesh_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__SimplePageContentCollection[] = {  {&_swigt__p_Ogre__SimplePageContentCollection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SimplePageContentCollectionFactory[] = {  {&_swigt__p_Ogre__SimplePageContentCollectionFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SimpleRenderable[] = {  {&_swigt__p_Ogre__SimpleRenderable, 0, 0, 0},  {&_swigt__p_Ogre__WireBoundingBox, _p_Ogre__WireBoundingBoxTo_p_Ogre__SimpleRenderable, 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__Skeleton[] = {  {&_swigt__p_Ogre__SkeletonInstance, _p_Ogre__SkeletonInstanceTo_p_Ogre__Skeleton, 0, 0},  {&_swigt__p_Ogre__Skeleton, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SkeletonInstance[] = {  {&_swigt__p_Ogre__SkeletonInstance, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SkeletonManager[] = {  {&_swigt__p_Ogre__SkeletonManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SkeletonPtr[] = {  {&_swigt__p_Ogre__SkeletonPtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SkeletonSerializer[] = {  {&_swigt__p_Ogre__SkeletonSerializer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Sphere[] = {  {&_swigt__p_Ogre__Sphere, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SphereSceneQuery[] = {  {&_swigt__p_Ogre__SphereSceneQuery, 0, 0, 0},  {&_swigt__p_Ogre__DefaultSphereSceneQuery, _p_Ogre__DefaultSphereSceneQueryTo_p_Ogre__SphereSceneQuery, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StaticFaceGroup[] = {  {&_swigt__p_Ogre__StaticFaceGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StaticGeometry[] = {  {&_swigt__p_Ogre__StaticGeometry, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StaticPluginLoader[] = {  {&_swigt__p_Ogre__StaticPluginLoader, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StreamSerialiser[] = {  {&_swigt__p_Ogre__StreamSerialiser, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StreamSerialiser__Chunk[] = {  {&_swigt__p_Ogre__StreamSerialiser__Chunk, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StringConverter[] = {  {&_swigt__p_Ogre__StringConverter, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StringInterface[] = {  {&_swigt__p_Ogre__PatchMesh, _p_Ogre__PatchMeshTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__Compositor, _p_Ogre__CompositorTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__Font, _p_Ogre__FontTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__Skeleton, _p_Ogre__SkeletonTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__Material, _p_Ogre__MaterialTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__Mesh, _p_Ogre__MeshTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__ExternalTextureSource, _p_Ogre__ExternalTextureSourceTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__ParticleSystem, _p_Ogre__ParticleSystemTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__OverlayContainer, _p_Ogre__OverlayContainerTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__SkeletonInstance, _p_Ogre__SkeletonInstanceTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__UnifiedHighLevelGpuProgram, _p_Ogre__UnifiedHighLevelGpuProgramTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__HighLevelGpuProgram, _p_Ogre__HighLevelGpuProgramTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__GpuProgram, _p_Ogre__GpuProgramTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__StringInterface, 0, 0, 0},  {&_swigt__p_Ogre__Texture, _p_Ogre__TextureTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__Resource, _p_Ogre__ResourceTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__BorderPanelOverlayElement, _p_Ogre__BorderPanelOverlayElementTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__PanelOverlayElement, _p_Ogre__PanelOverlayElementTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__OverlayElement, _p_Ogre__OverlayElementTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__TextAreaOverlayElement, _p_Ogre__TextAreaOverlayElementTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__BillboardParticleRenderer, _p_Ogre__BillboardParticleRendererTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__ParticleSystemRenderer, _p_Ogre__ParticleSystemRendererTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__ParticleAffector, _p_Ogre__ParticleAffectorTo_p_Ogre__StringInterface, 0, 0},  {&_swigt__p_Ogre__ParticleEmitter, _p_Ogre__ParticleEmitterTo_p_Ogre__StringInterface, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__StringUtil[] = {  {&_swigt__p_Ogre__StringUtil, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SubEntity[] = {  {&_swigt__p_Ogre__SubEntity, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__SubMesh[] = {  {&_swigt__p_Ogre__SubMesh, 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__TagPoint[] = {  {&_swigt__p_Ogre__TagPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TangentSpaceCalc[] = {  {&_swigt__p_Ogre__TangentSpaceCalc, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TangentSpaceCalc__Result[] = {  {&_swigt__p_Ogre__TangentSpaceCalc__Result, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Technique[] = {  {&_swigt__p_Ogre__Technique, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TechniqueTranslator[] = {  {&_swigt__p_Ogre__TechniqueTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TempBlendedBufferInfo[] = {  {&_swigt__p_Ogre__TempBlendedBufferInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Terrain[] = {  {&_swigt__p_Ogre__Terrain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainGlobalOptions[] = {  {&_swigt__p_Ogre__TerrainGlobalOptions, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainGroup[] = {  {&_swigt__p_Ogre__TerrainGroup, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainGroup__RayResult[] = {  {&_swigt__p_Ogre__TerrainGroup__RayResult, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainGroup__TerrainSlotDefinition[] = {  {&_swigt__p_Ogre__TerrainGroup__TerrainSlotDefinition, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainLayerBlendMap[] = {  {&_swigt__p_Ogre__TerrainLayerBlendMap, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainLayerDeclaration[] = {  {&_swigt__p_Ogre__TerrainLayerDeclaration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainLayerSampler[] = {  {&_swigt__p_Ogre__TerrainLayerSampler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainLayerSamplerElement[] = {  {&_swigt__p_Ogre__TerrainLayerSamplerElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainMaterialGenerator[] = {  {&_swigt__p_Ogre__TerrainMaterialGeneratorA, _p_Ogre__TerrainMaterialGeneratorATo_p_Ogre__TerrainMaterialGenerator, 0, 0},  {&_swigt__p_Ogre__TerrainMaterialGenerator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainMaterialGeneratorA[] = {  {&_swigt__p_Ogre__TerrainMaterialGeneratorA, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainMaterialGenerator__Profile[] = {  {&_swigt__p_Ogre__TerrainMaterialGenerator__Profile, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainPagedWorldSection[] = {  {&_swigt__p_Ogre__TerrainPagedWorldSection, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainPaging[] = {  {&_swigt__p_Ogre__TerrainPaging, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainQuadTreeNode[] = {  {&_swigt__p_Ogre__TerrainQuadTreeNode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TerrainQuadTreeNode__LodLevel[] = {  {&_swigt__p_Ogre__TerrainQuadTreeNode__LodLevel, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Terrain__GpuBufferAllocator[] = {  {&_swigt__p_Ogre__Terrain__GpuBufferAllocator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Terrain__ImportData[] = {  {&_swigt__p_Ogre__Terrain__ImportData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TexCoordModifierControllerValue[] = {  {&_swigt__p_Ogre__TexCoordModifierControllerValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextAreaOverlayElement[] = {  {&_swigt__p_Ogre__TextAreaOverlayElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextAreaOverlayElementFactory[] = {  {&_swigt__p_Ogre__TextAreaOverlayElementFactory, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Texture[] = {  {&_swigt__p_Ogre__Texture, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextureFrameControllerValue[] = {  {&_swigt__p_Ogre__TextureFrameControllerValue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextureManager[] = {  {&_swigt__p_Ogre__TextureManager, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TexturePtr[] = {  {&_swigt__p_Ogre__TexturePtr, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextureSourceTranslator[] = {  {&_swigt__p_Ogre__TextureSourceTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextureUnitState[] = {  {&_swigt__p_Ogre__TextureUnitState, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextureUnitState__TextureEffect[] = {  {&_swigt__p_Ogre__TextureUnitState__TextureEffect, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextureUnitState__UVWAddressingMode[] = {  {&_swigt__p_Ogre__TextureUnitState__UVWAddressingMode, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TextureUnitTranslator[] = {  {&_swigt__p_Ogre__TextureUnitTranslator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TimeIndex[] = {  {&_swigt__p_Ogre__TimeIndex, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Timer[] = {  {&_swigt__p_Ogre__Timer, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__TransformKeyFrame[] = {  {&_swigt__p_Ogre__TransformKeyFrame, 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__UTFString___const_fwd_iterator[] = {  {&_swigt__p_Ogre__UTFString___const_fwd_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UTFString___const_rev_iterator[] = {  {&_swigt__p_Ogre__UTFString___const_rev_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UTFString___fwd_iterator[] = {  {&_swigt__p_Ogre__UTFString___fwd_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UTFString___rev_iterator[] = {  {&_swigt__p_Ogre__UTFString___rev_iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UnifiedHighLevelGpuProgram[] = {  {&_swigt__p_Ogre__UnifiedHighLevelGpuProgram, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UnimplementedException[] = {  {&_swigt__p_Ogre__UnimplementedException, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__UserObjectBindings[] = {  {&_swigt__p_Ogre__UserObjectBindings, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VariableAccessAbstractNode[] = {  {&_swigt__p_Ogre__VariableAccessAbstractNode, 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__Vector4[] = {  {&_swigt__p_Ogre__Vector4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type_t, 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__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t[] = {  {&_swigt__p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexAnimationTrack[] = {  {&_swigt__p_Ogre__VertexAnimationTrack, 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__VertexBufferBinding[] = {  {&_swigt__p_Ogre__VertexBufferBinding, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexCacheProfiler[] = {  {&_swigt__p_Ogre__VertexCacheProfiler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexData[] = {  {&_swigt__p_Ogre__VertexData, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexDeclaration[] = {  {&_swigt__p_Ogre__VertexDeclaration, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexElement[] = {  {&_swigt__p_Ogre__VertexElement, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexMorphKeyFrame[] = {  {&_swigt__p_Ogre__VertexMorphKeyFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VertexPoseKeyFrame[] = {  {&_swigt__p_Ogre__VertexPoseKeyFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ViewPoint[] = {  {&_swigt__p_Ogre__ViewPoint, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Viewport[] = {  {&_swigt__p_Ogre__Viewport, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__Viewport__Listener[] = {  {&_swigt__p_Ogre__Viewport__Listener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__VisibleObjectsBoundsInfo[] = {  {&_swigt__p_Ogre__VisibleObjectsBoundsInfo, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WaveformControllerFunction[] = {  {&_swigt__p_Ogre__WaveformControllerFunction, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WindowEventListener[] = {  {&_swigt__p_Ogre__WindowEventListener, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WindowEventUtilities[] = {  {&_swigt__p_Ogre__WindowEventUtilities, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WireBoundingBox[] = {  {&_swigt__p_Ogre__WireBoundingBox, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WorkQueue[] = {  {&_swigt__p_Ogre__DefaultWorkQueueBase, _p_Ogre__DefaultWorkQueueBaseTo_p_Ogre__WorkQueue, 0, 0},  {&_swigt__p_Ogre__WorkQueue, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WorkQueue__Request[] = {  {&_swigt__p_Ogre__WorkQueue__Request, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WorkQueue__RequestHandler[] = {  {&_swigt__p_Ogre__WorkQueue__RequestHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WorkQueue__Response[] = {  {&_swigt__p_Ogre__WorkQueue__Response, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__WorkQueue__ResponseHandler[] = {  {&_swigt__p_Ogre__WorkQueue__ResponseHandler, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ZipArchive[] = {  {&_swigt__p_Ogre__ZipArchive, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__ZipArchiveFactory[] = {  {&_swigt__p_Ogre__ZipArchiveFactory, 0, 0, 0},  {&_swigt__p_Ogre__EmbeddedZipArchiveFactory, _p_Ogre__EmbeddedZipArchiveFactoryTo_p_Ogre__ZipArchiveFactory, 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__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_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__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_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__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_Ogre__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_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__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_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__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_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__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_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__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_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__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_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__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_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__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_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__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_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__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__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__String_Ogre__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_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__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_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_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__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_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__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_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__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_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__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_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__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_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__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_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__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_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__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_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__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_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__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_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__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_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_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_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_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_Ogre__GeneralAllocPolicy_t_t__type[] = {  {&_swigt__p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_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_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_ResourcePool[] = {  {&_swigt__p_ResourcePool, 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_a_3__float[] = {  {&_swigt__p_a_3__float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_bool[] = {  {&_swigt__p_bool, 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_double[] = {  {&_swigt__p_double, 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_f_size_t_p_void_size_t__bool[] = {  {&_swigt__p_f_size_t_p_void_size_t__bool, 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_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[] = {  {&_swigt__p_long, 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_p_Ogre__NumericKeyFrame[] = {{&_swigt__p_p_Ogre__NumericKeyFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Ogre__TransformKeyFrame[] = {{&_swigt__p_p_Ogre__TransformKeyFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Ogre__VertexMorphKeyFrame[] = {{&_swigt__p_p_Ogre__VertexMorphKeyFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Ogre__VertexPoseKeyFrame[] = {{&_swigt__p_p_Ogre__VertexPoseKeyFrame, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Ogre__KeyFrame[] = {  {&_swigt__p_p_Ogre__KeyFrame, 0, 0, 0},  {&_swigt__p_p_Ogre__NumericKeyFrame, _p_p_Ogre__NumericKeyFrameTo_p_p_Ogre__KeyFrame, 0, 0},  {&_swigt__p_p_Ogre__TransformKeyFrame, _p_p_Ogre__TransformKeyFrameTo_p_p_Ogre__KeyFrame, 0, 0},  {&_swigt__p_p_Ogre__VertexMorphKeyFrame, _p_p_Ogre__VertexMorphKeyFrameTo_p_p_Ogre__KeyFrame, 0, 0},  {&_swigt__p_p_Ogre__VertexPoseKeyFrame, _p_p_Ogre__VertexPoseKeyFrameTo_p_p_Ogre__KeyFrame, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Ogre__LinkedSkeletonAnimationSource[] = {  {&_swigt__p_p_Ogre__LinkedSkeletonAnimationSource, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Ogre__Matrix4[] = {  {&_swigt__p_p_Ogre__Matrix4, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_Ogre__Terrain[] = {  {&_swigt__p_p_Ogre__Terrain, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_float[] = {  {&_swigt__p_p_float, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_unsigned_char[] = {  {&_swigt__p_p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_unsigned_int[] = {  {&_swigt__p_p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_unsigned_short[] = {  {&_swigt__p_p_unsigned_short, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_p_void[] = {  {&_swigt__p_p_void, 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_t[] = {  {&_swigt__p_size_t, 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_stringT_unsigned_int_t[] = {  {&_swigt__p_std__basic_stringT_unsigned_int_t, 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__exception[] = {  {&_swigt__p_std__exception, 0, 0, 0},  {&_swigt__p_Ogre__Exception, _p_Ogre__ExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__UnimplementedException, _p_Ogre__UnimplementedExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__FileNotFoundException, _p_Ogre__FileNotFoundExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__IOException, _p_Ogre__IOExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__InvalidStateException, _p_Ogre__InvalidStateExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__InvalidParametersException, _p_Ogre__InvalidParametersExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__ItemIdentityException, _p_Ogre__ItemIdentityExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__InternalErrorException, _p_Ogre__InternalErrorExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__RenderingAPIException, _p_Ogre__RenderingAPIExceptionTo_p_std__exception, 0, 0},  {&_swigt__p_Ogre__RuntimeAssertionException, _p_Ogre__RuntimeAssertionExceptionTo_p_std__exception, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__fstream[] = {  {&_swigt__p_std__fstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ifstream[] = {  {&_swigt__p_std__ifstream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ios__fmtflags[] = {  {&_swigt__p_std__ios__fmtflags, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__ostream[] = {  {&_swigt__p_std__ostream, 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__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t[] = {  {&_swigt__p_std__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t[] = {  {&_swigt__p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_bool_Ogre__Vector3_t[] = {  {&_swigt__p_std__pairT_bool_Ogre__Vector3_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_bool_float_t[] = {  {&_swigt__p_std__pairT_bool_float_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_bool_std__string_t[] = {  {&_swigt__p_std__pairT_bool_std__string_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_size_t_size_t_t[] = {  {&_swigt__p_std__pairT_size_t_size_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_unsigned_char_unsigned_char_t[] = {  {&_swigt__p_std__pairT_unsigned_char_unsigned_char_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__pairT_unsigned_int_unsigned_int_t[] = {  {&_swigt__p_std__pairT_unsigned_int_unsigned_int_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__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t[] = {  {&_swigt__p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__type_info[] = {  {&_swigt__p_std__type_info, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t[] = {  {&_swigt__p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t[] = {  {&_swigt__p_std__vectorT_std__string_std__allocatorT_std__string_t_t, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__wostream[] = {  {&_swigt__p_std__wostream, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_std__wstring[] = {  {&_swigt__p_std__wstring, 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_swig__ConstIterator[] = {  {&_swigt__p_swig__ConstIterator, 0, 0, 0},  {&_swigt__p_swig__Iterator, _p_swig__IteratorTo_p_swig__ConstIterator, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__GC_VALUE[] = {  {&_swigt__p_swig__GC_VALUE, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_swig__Iterator[] = {  {&_swigt__p_swig__Iterator, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_time_t[] = {  {&_swigt__p_time_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_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
static swig_cast_info _swigc__p_wchar_t[] = {  {&_swigt__p_wchar_t, 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_AutoConstantEntry,
  _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_FILE,
  _swigc__p_FactoryMap,
  _swigc__p_GPUDeviceNameRule,
  _swigc__p_GPUDeviceNameRuleIterator,
  _swigc__p_GPUDeviceNameRuleList,
  _swigc__p_GPUVendorRule,
  _swigc__p_GPUVendorRuleIterator,
  _swigc__p_GPUVendorRuleList,
  _swigc__p_GpuSharedParamUsageList,
  _swigc__p_HardwareAnimationDataList,
  _swigc__p_IdMap,
  _swigc__p_IlluminationPassIterator,
  _swigc__p_ImportData,
  _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__AbstractNode,
  _swigc__p_Ogre__AlignedMemory,
  _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__Angle,
  _swigc__p_Ogre__AnimableObject,
  _swigc__p_Ogre__AnimableValue,
  _swigc__p_Ogre__Animation,
  _swigc__p_Ogre__AnimationContainer,
  _swigc__p_Ogre__AnimationControllerFunction,
  _swigc__p_Ogre__AnimationState,
  _swigc__p_Ogre__AnimationStateControllerValue,
  _swigc__p_Ogre__AnimationStateIterator,
  _swigc__p_Ogre__AnimationStateSet,
  _swigc__p_Ogre__AnimationTrack,
  _swigc__p_Ogre__AnimationTrack__Listener,
  _swigc__p_Ogre__Any,
  _swigc__p_Ogre__AnyNumeric,
  _swigc__p_Ogre__AnyVALUE,
  _swigc__p_Ogre__Archive,
  _swigc__p_Ogre__ArchiveFactory,
  _swigc__p_Ogre__ArchiveManager,
  _swigc__p_Ogre__AtomAbstractNode,
  _swigc__p_Ogre__AutoParamDataSource,
  _swigc__p_Ogre__AxisAlignedBox,
  _swigc__p_Ogre__AxisAlignedBoxSceneQuery,
  _swigc__p_Ogre__BackgroundProcessResult,
  _swigc__p_Ogre__BaseInstanceBatchVTF,
  _swigc__p_Ogre__Billboard,
  _swigc__p_Ogre__BillboardChain,
  _swigc__p_Ogre__BillboardChainFactory,
  _swigc__p_Ogre__BillboardChain__Element,
  _swigc__p_Ogre__BillboardParticleRenderer,
  _swigc__p_Ogre__BillboardParticleRendererFactory,
  _swigc__p_Ogre__BillboardSet,
  _swigc__p_Ogre__BillboardSetFactory,
  _swigc__p_Ogre__Bitwise,
  _swigc__p_Ogre__Bone,
  _swigc__p_Ogre__BorderPanelOverlayElement,
  _swigc__p_Ogre__BorderPanelOverlayElementFactory,
  _swigc__p_Ogre__BorderRenderable,
  _swigc__p_Ogre__Box,
  _swigc__p_Ogre__BuiltinScriptTranslatorManager,
  _swigc__p_Ogre__Camera,
  _swigc__p_Ogre__Camera__Listener,
  _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__Codec,
  _swigc__p_Ogre__ColourValue,
  _swigc__p_Ogre__CompositionPass,
  _swigc__p_Ogre__CompositionPassTranslator,
  _swigc__p_Ogre__CompositionPass__InputTex,
  _swigc__p_Ogre__CompositionTargetPass,
  _swigc__p_Ogre__CompositionTargetPassTranslator,
  _swigc__p_Ogre__CompositionTechnique,
  _swigc__p_Ogre__CompositionTechniqueTranslator,
  _swigc__p_Ogre__CompositionTechnique__TextureDefinition,
  _swigc__p_Ogre__Compositor,
  _swigc__p_Ogre__CompositorChain,
  _swigc__p_Ogre__CompositorInstance,
  _swigc__p_Ogre__CompositorInstance__Listener,
  _swigc__p_Ogre__CompositorInstance__RenderSystemOperation,
  _swigc__p_Ogre__CompositorInstance__TargetOperation,
  _swigc__p_Ogre__CompositorLogic,
  _swigc__p_Ogre__CompositorManager,
  _swigc__p_Ogre__CompositorPtr,
  _swigc__p_Ogre__CompositorTranslator,
  _swigc__p_Ogre__ConcreteNode,
  _swigc__p_Ogre__ConfigFile,
  _swigc__p_Ogre__ConstAnimationStateIterator,
  _swigc__p_Ogre__ConstEnabledAnimationStateIterator,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__RenderQueueGroupMap_t,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__Codec_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Codec_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _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__ConstMapIteratorT_Ogre__mapT_Ogre__String_Ogre__InstanceManager__InstanceBatchVec_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__InstanceManager__InstanceBatchVec_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstMapIteratorT_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_t,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstMapIteratorT_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstShadowTextureConfigIterator,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUDeviceNameRule_Ogre__STLAllocatorT_GPUDeviceNameRule_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_GPUVendorRule_Ogre__STLAllocatorT_GPUVendorRule_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__InstanceBatch_p_Ogre__STLAllocatorT_Ogre__InstanceBatch_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__LinkedSkeletonAnimationSource_Ogre__STLAllocatorT_Ogre__LinkedSkeletonAnimationSource_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Node_p_Ogre__STLAllocatorT_Ogre__Node_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ConstVectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__ControllerManager,
  _swigc__p_Ogre__ControllerT_float_t,
  _swigc__p_Ogre__ConvexBody,
  _swigc__p_Ogre__CreateCompositorScriptCompilerEvent,
  _swigc__p_Ogre__CreateGpuProgramScriptCompilerEvent,
  _swigc__p_Ogre__CreateGpuSharedParametersScriptCompilerEvent,
  _swigc__p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent,
  _swigc__p_Ogre__CreateMaterialScriptCompilerEvent,
  _swigc__p_Ogre__CreateParticleSystemScriptCompilerEvent,
  _swigc__p_Ogre__CustomCompositionPass,
  _swigc__p_Ogre__DDSCodec,
  _swigc__p_Ogre__DataStream,
  _swigc__p_Ogre__DefaultAxisAlignedBoxSceneQuery,
  _swigc__p_Ogre__DefaultHardwareBufferManager,
  _swigc__p_Ogre__DefaultHardwareBufferManagerBase,
  _swigc__p_Ogre__DefaultHardwareIndexBuffer,
  _swigc__p_Ogre__DefaultHardwareVertexBuffer,
  _swigc__p_Ogre__DefaultIntersectionSceneQuery,
  _swigc__p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery,
  _swigc__p_Ogre__DefaultRaySceneQuery,
  _swigc__p_Ogre__DefaultSceneManager,
  _swigc__p_Ogre__DefaultSceneManagerFactory,
  _swigc__p_Ogre__DefaultShadowCameraSetup,
  _swigc__p_Ogre__DefaultSphereSceneQuery,
  _swigc__p_Ogre__DefaultWorkQueueBase,
  _swigc__p_Ogre__DeflateStream,
  _swigc__p_Ogre__Degree,
  _swigc__p_Ogre__DepthBuffer,
  _swigc__p_Ogre__DistanceLodStrategy,
  _swigc__p_Ogre__DriverVersion,
  _swigc__p_Ogre__DualQuaternion,
  _swigc__p_Ogre__DynLib,
  _swigc__p_Ogre__DynLibManager,
  _swigc__p_Ogre__EdgeData,
  _swigc__p_Ogre__EdgeData__Triangle,
  _swigc__p_Ogre__EdgeListBuilder,
  _swigc__p_Ogre__EmbeddedZipArchiveFactory,
  _swigc__p_Ogre__EmitterCommands__CmdAngle,
  _swigc__p_Ogre__EmitterCommands__CmdColour,
  _swigc__p_Ogre__EmitterCommands__CmdColourRangeEnd,
  _swigc__p_Ogre__EmitterCommands__CmdColourRangeStart,
  _swigc__p_Ogre__EmitterCommands__CmdDirection,
  _swigc__p_Ogre__EmitterCommands__CmdDuration,
  _swigc__p_Ogre__EmitterCommands__CmdEmissionRate,
  _swigc__p_Ogre__EmitterCommands__CmdEmittedEmitter,
  _swigc__p_Ogre__EmitterCommands__CmdMaxDuration,
  _swigc__p_Ogre__EmitterCommands__CmdMaxRepeatDelay,
  _swigc__p_Ogre__EmitterCommands__CmdMaxTTL,
  _swigc__p_Ogre__EmitterCommands__CmdMaxVelocity,
  _swigc__p_Ogre__EmitterCommands__CmdMinDuration,
  _swigc__p_Ogre__EmitterCommands__CmdMinRepeatDelay,
  _swigc__p_Ogre__EmitterCommands__CmdMinTTL,
  _swigc__p_Ogre__EmitterCommands__CmdMinVelocity,
  _swigc__p_Ogre__EmitterCommands__CmdName,
  _swigc__p_Ogre__EmitterCommands__CmdPosition,
  _swigc__p_Ogre__EmitterCommands__CmdRepeatDelay,
  _swigc__p_Ogre__EmitterCommands__CmdTTL,
  _swigc__p_Ogre__EmitterCommands__CmdUp,
  _swigc__p_Ogre__EmitterCommands__CmdVelocity,
  _swigc__p_Ogre__Entity,
  _swigc__p_Ogre__EntityFactory,
  _swigc__p_Ogre__EntityMaterialLodChangedEvent,
  _swigc__p_Ogre__EntityMeshLodChangedEvent,
  _swigc__p_Ogre__Exception,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_CANNOT_WRITE_TO_FILE_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_DUPLICATE_ITEM_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_FILE_NOT_FOUND_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INTERNAL_ERROR_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALIDPARAMS_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_INVALID_STATE_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_ITEM_NOT_FOUND_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_NOT_IMPLEMENTED_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RENDERINGAPI_ERROR_t,
  _swigc__p_Ogre__ExceptionCodeTypeT_Ogre__Exception__ERR_RT_ASSERTION_FAILED_t,
  _swigc__p_Ogre__ExceptionFactory,
  _swigc__p_Ogre__ExternalTextureSource,
  _swigc__p_Ogre__ExternalTextureSourceManager,
  _swigc__p_Ogre__FileHandleDataStream,
  _swigc__p_Ogre__FileInfo,
  _swigc__p_Ogre__FileNotFoundException,
  _swigc__p_Ogre__FileStreamDataStream,
  _swigc__p_Ogre__FileSystemArchive,
  _swigc__p_Ogre__FileSystemArchiveFactory,
  _swigc__p_Ogre__FloatGpuParameterControllerValue,
  _swigc__p_Ogre__FocusedShadowCameraSetup,
  _swigc__p_Ogre__Font,
  _swigc__p_Ogre__FontManager,
  _swigc__p_Ogre__FontPtr,
  _swigc__p_Ogre__Font__GlyphInfo,
  _swigc__p_Ogre__FrameEvent,
  _swigc__p_Ogre__FrameListener,
  _swigc__p_Ogre__FrameTimeControllerValue,
  _swigc__p_Ogre__FreeImageCodec,
  _swigc__p_Ogre__Frustum,
  _swigc__p_Ogre__FrustumPlane,
  _swigc__p_Ogre__GpuConstantDefinition,
  _swigc__p_Ogre__GpuLogicalBufferStruct,
  _swigc__p_Ogre__GpuLogicalIndexUse,
  _swigc__p_Ogre__GpuNamedConstants,
  _swigc__p_Ogre__GpuNamedConstantsSerializer,
  _swigc__p_Ogre__GpuProgram,
  _swigc__p_Ogre__GpuProgramManager,
  _swigc__p_Ogre__GpuProgramParameters,
  _swigc__p_Ogre__GpuProgramParameters__AutoConstantDefinition,
  _swigc__p_Ogre__GpuProgramParameters__AutoConstantEntry,
  _swigc__p_Ogre__GpuProgramPtr,
  _swigc__p_Ogre__GpuProgramTranslator,
  _swigc__p_Ogre__GpuProgramUsage,
  _swigc__p_Ogre__GpuSharedParameters,
  _swigc__p_Ogre__GpuSharedParametersUsage,
  _swigc__p_Ogre__Grid2DPageStrategy,
  _swigc__p_Ogre__Grid2DPageStrategyData,
  _swigc__p_Ogre__Grid3DPageStrategy,
  _swigc__p_Ogre__Grid3DPageStrategyData,
  _swigc__p_Ogre__HardwareBuffer,
  _swigc__p_Ogre__HardwareBufferLicensee,
  _swigc__p_Ogre__HardwareBufferManager,
  _swigc__p_Ogre__HardwareBufferManagerBase,
  _swigc__p_Ogre__HardwareIndexBuffer,
  _swigc__p_Ogre__HardwareIndexBufferSharedPtr,
  _swigc__p_Ogre__HardwareOcclusionQuery,
  _swigc__p_Ogre__HardwarePixelBuffer,
  _swigc__p_Ogre__HardwarePixelBufferSharedPtr,
  _swigc__p_Ogre__HardwareVertexBuffer,
  _swigc__p_Ogre__HardwareVertexBufferSharedPtr,
  _swigc__p_Ogre__HashedVectorT_Ogre__Light_p_t,
  _swigc__p_Ogre__HighLevelGpuProgram,
  _swigc__p_Ogre__HighLevelGpuProgramFactory,
  _swigc__p_Ogre__HighLevelGpuProgramManager,
  _swigc__p_Ogre__HighLevelGpuProgramPtr,
  _swigc__p_Ogre__IOException,
  _swigc__p_Ogre__IlluminationPass,
  _swigc__p_Ogre__Image,
  _swigc__p_Ogre__ImageCodec,
  _swigc__p_Ogre__ImportAbstractNode,
  _swigc__p_Ogre__IndexData,
  _swigc__p_Ogre__InstanceBatch,
  _swigc__p_Ogre__InstanceBatchHW,
  _swigc__p_Ogre__InstanceBatchHW_VTF,
  _swigc__p_Ogre__InstanceBatchShader,
  _swigc__p_Ogre__InstanceBatchVTF,
  _swigc__p_Ogre__InstanceManager,
  _swigc__p_Ogre__InstancedEntity,
  _swigc__p_Ogre__InstancedGeometry,
  _swigc__p_Ogre__InstancedGeometry__BatchInstanceIterator,
  _swigc__p_Ogre__InternalErrorException,
  _swigc__p_Ogre__IntersectionSceneQuery,
  _swigc__p_Ogre__IntersectionSceneQueryListener,
  _swigc__p_Ogre__IntersectionSceneQueryResult,
  _swigc__p_Ogre__InvalidParametersException,
  _swigc__p_Ogre__InvalidStateException,
  _swigc__p_Ogre__ItemIdentityException,
  _swigc__p_Ogre__KeyFrame,
  _swigc__p_Ogre__LayerBlendModeEx,
  _swigc__p_Ogre__LiSPSMShadowCameraSetup,
  _swigc__p_Ogre__Light,
  _swigc__p_Ogre__LightFactory,
  _swigc__p_Ogre__LinkedSkeletonAnimationSource,
  _swigc__p_Ogre__LodListener,
  _swigc__p_Ogre__LodStrategy,
  _swigc__p_Ogre__LodStrategyManager,
  _swigc__p_Ogre__Log,
  _swigc__p_Ogre__LogListener,
  _swigc__p_Ogre__LogManager,
  _swigc__p_Ogre__Log__Stream,
  _swigc__p_Ogre__ManualObject,
  _swigc__p_Ogre__ManualObjectFactory,
  _swigc__p_Ogre__ManualObject__ManualObjectSection,
  _swigc__p_Ogre__ManualResourceLoader,
  _swigc__p_Ogre__MapIteratorT_Ogre__RenderQueueGroupMap_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Archive_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Archive_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ConfigFile__SettingsMultiMap_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ConfigFile__SettingsMultiMap_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__MovableObject_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__MovableObject_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayContainer_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayContainer_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__OverlayElement_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElement_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__Overlay_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__Overlay_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleAffectorFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleAffectorFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleEmitterFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleEmitterFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystemRendererFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystemRendererFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__String_Ogre__ParticleSystem_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__ParticleSystem_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_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_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_Ogre__Region_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_Ogre__Region_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_Ogre__uint32_TerrainSlot_p_std__lessT_Ogre__uint32_t_Ogre__STLAllocatorT_std__pairT_Ogre__uint32_const_TerrainSlot_p_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__multimapT_Ogre__String_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__MapIteratorT_Ogre__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__Material,
  _swigc__p_Ogre__MaterialManager,
  _swigc__p_Ogre__MaterialManager__Listener,
  _swigc__p_Ogre__MaterialPtr,
  _swigc__p_Ogre__MaterialScriptContext,
  _swigc__p_Ogre__MaterialScriptProgramDefinition,
  _swigc__p_Ogre__MaterialSerializer,
  _swigc__p_Ogre__MaterialSerializer__Listener,
  _swigc__p_Ogre__MaterialTranslator,
  _swigc__p_Ogre__Math,
  _swigc__p_Ogre__Matrix3,
  _swigc__p_Ogre__Matrix4,
  _swigc__p_Ogre__MemoryDataStream,
  _swigc__p_Ogre__Mesh,
  _swigc__p_Ogre__MeshLodUsage,
  _swigc__p_Ogre__MeshManager,
  _swigc__p_Ogre__MeshPtr,
  _swigc__p_Ogre__MeshSerializer,
  _swigc__p_Ogre__MeshSerializerListener,
  _swigc__p_Ogre__MovableObject,
  _swigc__p_Ogre__MovableObjectFactory,
  _swigc__p_Ogre__MovableObjectLodChangedEvent,
  _swigc__p_Ogre__MovableObject__Listener,
  _swigc__p_Ogre__MovablePlane,
  _swigc__p_Ogre__MultiRenderTarget,
  _swigc__p_Ogre__NameGenerator,
  _swigc__p_Ogre__NedPoolingImpl,
  _swigc__p_Ogre__NedPoolingPolicy,
  _swigc__p_Ogre__Node,
  _swigc__p_Ogre__NodeAnimationTrack,
  _swigc__p_Ogre__Node__DebugRenderable,
  _swigc__p_Ogre__Node__Listener,
  _swigc__p_Ogre__NumericAnimationTrack,
  _swigc__p_Ogre__NumericKeyFrame,
  _swigc__p_Ogre__ObjectAbstractNode,
  _swigc__p_Ogre__OptimisedUtil,
  _swigc__p_Ogre__Overlay,
  _swigc__p_Ogre__OverlayContainer,
  _swigc__p_Ogre__OverlayElement,
  _swigc__p_Ogre__OverlayElementCommands__CmdCaption,
  _swigc__p_Ogre__OverlayElementCommands__CmdHeight,
  _swigc__p_Ogre__OverlayElementCommands__CmdHorizontalAlign,
  _swigc__p_Ogre__OverlayElementCommands__CmdLeft,
  _swigc__p_Ogre__OverlayElementCommands__CmdMaterial,
  _swigc__p_Ogre__OverlayElementCommands__CmdMetricsMode,
  _swigc__p_Ogre__OverlayElementCommands__CmdTop,
  _swigc__p_Ogre__OverlayElementCommands__CmdVerticalAlign,
  _swigc__p_Ogre__OverlayElementCommands__CmdVisible,
  _swigc__p_Ogre__OverlayElementCommands__CmdWidth,
  _swigc__p_Ogre__OverlayElementFactory,
  _swigc__p_Ogre__OverlayManager,
  _swigc__p_Ogre__PSSMShadowCameraSetup,
  _swigc__p_Ogre__Page,
  _swigc__p_Ogre__PageContent,
  _swigc__p_Ogre__PageContentCollection,
  _swigc__p_Ogre__PageContentCollectionFactory,
  _swigc__p_Ogre__PageContentFactory,
  _swigc__p_Ogre__PageManager,
  _swigc__p_Ogre__PageProvider,
  _swigc__p_Ogre__PageStrategy,
  _swigc__p_Ogre__PageStrategyData,
  _swigc__p_Ogre__PagedWorld,
  _swigc__p_Ogre__PagedWorldSection,
  _swigc__p_Ogre__PagedWorldSectionFactory,
  _swigc__p_Ogre__PanelOverlayElement,
  _swigc__p_Ogre__PanelOverlayElementFactory,
  _swigc__p_Ogre__ParamCommand,
  _swigc__p_Ogre__ParamDictionary,
  _swigc__p_Ogre__ParameterDef,
  _swigc__p_Ogre__Particle,
  _swigc__p_Ogre__ParticleAffector,
  _swigc__p_Ogre__ParticleAffectorFactory,
  _swigc__p_Ogre__ParticleAffectorTranslator,
  _swigc__p_Ogre__ParticleEmitter,
  _swigc__p_Ogre__ParticleEmitterFactory,
  _swigc__p_Ogre__ParticleEmitterTranslator,
  _swigc__p_Ogre__ParticleIterator,
  _swigc__p_Ogre__ParticleSystem,
  _swigc__p_Ogre__ParticleSystemFactory,
  _swigc__p_Ogre__ParticleSystemManager,
  _swigc__p_Ogre__ParticleSystemRenderer,
  _swigc__p_Ogre__ParticleSystemRendererFactory,
  _swigc__p_Ogre__ParticleSystemTranslator,
  _swigc__p_Ogre__ParticleVisualData,
  _swigc__p_Ogre__Pass,
  _swigc__p_Ogre__PassTranslator,
  _swigc__p_Ogre__Pass__HashFunc,
  _swigc__p_Ogre__PassthroughControllerFunction,
  _swigc__p_Ogre__PatchMesh,
  _swigc__p_Ogre__PatchMeshPtr,
  _swigc__p_Ogre__PatchSurface,
  _swigc__p_Ogre__PixelBox,
  _swigc__p_Ogre__PixelCountLodStrategy,
  _swigc__p_Ogre__PixelUtil,
  _swigc__p_Ogre__Plane,
  _swigc__p_Ogre__PlaneBoundedVolume,
  _swigc__p_Ogre__PlaneBoundedVolumeListSceneQuery,
  _swigc__p_Ogre__PlaneOptimalShadowCameraSetup,
  _swigc__p_Ogre__PlatformInformation,
  _swigc__p_Ogre__Plugin,
  _swigc__p_Ogre__Polygon,
  _swigc__p_Ogre__Pose,
  _swigc__p_Ogre__PreApplyTextureAliasesScriptCompilerEvent,
  _swigc__p_Ogre__PrefabFactory,
  _swigc__p_Ogre__ProcessNameExclusionScriptCompilerEvent,
  _swigc__p_Ogre__ProcessResourceNameScriptCompilerEvent,
  _swigc__p_Ogre__Profile,
  _swigc__p_Ogre__Profiler,
  _swigc__p_Ogre__PropertyAbstractNode,
  _swigc__p_Ogre__Quaternion,
  _swigc__p_Ogre__QueuedRenderableCollection,
  _swigc__p_Ogre__QueuedRenderableVisitor,
  _swigc__p_Ogre__Radian,
  _swigc__p_Ogre__Ray,
  _swigc__p_Ogre__RaySceneQuery,
  _swigc__p_Ogre__RaySceneQueryListener,
  _swigc__p_Ogre__RaySceneQueryResultEntry,
  _swigc__p_Ogre__Rectangle,
  _swigc__p_Ogre__Rectangle2D,
  _swigc__p_Ogre__RegionSceneQuery,
  _swigc__p_Ogre__RenderObjectListener,
  _swigc__p_Ogre__RenderOperation,
  _swigc__p_Ogre__RenderPriorityGroup,
  _swigc__p_Ogre__RenderQueue,
  _swigc__p_Ogre__RenderQueueGroup,
  _swigc__p_Ogre__RenderQueueGroup__ConstPriorityMapIterator,
  _swigc__p_Ogre__RenderQueueGroup__PriorityMapIterator,
  _swigc__p_Ogre__RenderQueueInvocation,
  _swigc__p_Ogre__RenderQueueInvocationSequence,
  _swigc__p_Ogre__RenderQueueListener,
  _swigc__p_Ogre__RenderQueue__RenderableListener,
  _swigc__p_Ogre__RenderSystem,
  _swigc__p_Ogre__RenderSystemCapabilities,
  _swigc__p_Ogre__RenderSystemCapabilitiesManager,
  _swigc__p_Ogre__RenderSystemCapabilitiesSerializer,
  _swigc__p_Ogre__RenderSystem__Listener,
  _swigc__p_Ogre__RenderSystem__RenderSystemContext,
  _swigc__p_Ogre__RenderTarget,
  _swigc__p_Ogre__RenderTargetEvent,
  _swigc__p_Ogre__RenderTargetListener,
  _swigc__p_Ogre__RenderTargetViewportEvent,
  _swigc__p_Ogre__RenderTarget__FrameStats,
  _swigc__p_Ogre__RenderTarget__Impl,
  _swigc__p_Ogre__RenderTexture,
  _swigc__p_Ogre__RenderToVertexBuffer,
  _swigc__p_Ogre__RenderWindow,
  _swigc__p_Ogre__RenderWindowDescription,
  _swigc__p_Ogre__Renderable,
  _swigc__p_Ogre__RenderablePass,
  _swigc__p_Ogre__Renderable__RenderSystemData,
  _swigc__p_Ogre__Renderable__Visitor,
  _swigc__p_Ogre__RenderingAPIException,
  _swigc__p_Ogre__Resource,
  _swigc__p_Ogre__ResourceBackgroundQueue,
  _swigc__p_Ogre__ResourceBackgroundQueue__Listener,
  _swigc__p_Ogre__ResourceGroupListener,
  _swigc__p_Ogre__ResourceGroupManager,
  _swigc__p_Ogre__ResourceGroupManager__ResourceManagerIterator,
  _swigc__p_Ogre__ResourceLoadingListener,
  _swigc__p_Ogre__ResourceManager,
  _swigc__p_Ogre__ResourceManager__ResourceMapIterator,
  _swigc__p_Ogre__ResourceManager__ResourcePool,
  _swigc__p_Ogre__Resource__Listener,
  _swigc__p_Ogre__RibbonTrail,
  _swigc__p_Ogre__RibbonTrailFactory,
  _swigc__p_Ogre__Root,
  _swigc__p_Ogre__Root__MovableObjectFactoryIterator,
  _swigc__p_Ogre__RotationalSpline,
  _swigc__p_Ogre__RuntimeAssertionException,
  _swigc__p_Ogre__ScaleControllerFunction,
  _swigc__p_Ogre__SceneManager,
  _swigc__p_Ogre__SceneManagerEnumerator,
  _swigc__p_Ogre__SceneManagerEnumerator__MetaDataIterator,
  _swigc__p_Ogre__SceneManagerEnumerator__SceneManagerIterator,
  _swigc__p_Ogre__SceneManagerFactory,
  _swigc__p_Ogre__SceneManagerMetaData,
  _swigc__p_Ogre__SceneManager__AnimationIterator,
  _swigc__p_Ogre__SceneManager__CameraIterator,
  _swigc__p_Ogre__SceneManager__Listener,
  _swigc__p_Ogre__SceneManager__MovableObjectIterator,
  _swigc__p_Ogre__SceneManager__RenderContext,
  _swigc__p_Ogre__SceneManager__SceneMgrQueuedRenderableVisitor,
  _swigc__p_Ogre__SceneManager__SkyBoxGenParameters,
  _swigc__p_Ogre__SceneManager__SkyDomeGenParameters,
  _swigc__p_Ogre__SceneManager__SkyPlaneGenParameters,
  _swigc__p_Ogre__SceneNode,
  _swigc__p_Ogre__SceneQuery,
  _swigc__p_Ogre__SceneQueryListener,
  _swigc__p_Ogre__SceneQueryResult,
  _swigc__p_Ogre__SceneQuery__WorldFragment,
  _swigc__p_Ogre__ScriptCompiler,
  _swigc__p_Ogre__ScriptCompilerEvent,
  _swigc__p_Ogre__ScriptCompilerListener,
  _swigc__p_Ogre__ScriptCompilerManager,
  _swigc__p_Ogre__ScriptLexer,
  _swigc__p_Ogre__ScriptLoader,
  _swigc__p_Ogre__ScriptParser,
  _swigc__p_Ogre__ScriptToken,
  _swigc__p_Ogre__ScriptTranslator,
  _swigc__p_Ogre__ScriptTranslatorManager,
  _swigc__p_Ogre__Serializer,
  _swigc__p_Ogre__ShadowCameraSetup,
  _swigc__p_Ogre__ShadowCaster,
  _swigc__p_Ogre__ShadowRenderable,
  _swigc__p_Ogre__ShadowTextureConfig,
  _swigc__p_Ogre__ShadowTextureManager,
  _swigc__p_Ogre__ShadowVolumeExtrudeProgram,
  _swigc__p_Ogre__SharedParamsTranslator,
  _swigc__p_Ogre__SharedPtrT_Ogre__AbstractNode_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__AnimableValue_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__CodecData_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__Material_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__MemoryDataStream_t,
  _swigc__p_Ogre__SharedPtrT_Ogre__Mesh_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__SimplePageContentCollection,
  _swigc__p_Ogre__SimplePageContentCollectionFactory,
  _swigc__p_Ogre__SimpleRenderable,
  _swigc__p_Ogre__SimpleSpline,
  _swigc__p_Ogre__Skeleton,
  _swigc__p_Ogre__SkeletonInstance,
  _swigc__p_Ogre__SkeletonManager,
  _swigc__p_Ogre__SkeletonPtr,
  _swigc__p_Ogre__SkeletonSerializer,
  _swigc__p_Ogre__Sphere,
  _swigc__p_Ogre__SphereSceneQuery,
  _swigc__p_Ogre__StaticFaceGroup,
  _swigc__p_Ogre__StaticGeometry,
  _swigc__p_Ogre__StaticPluginLoader,
  _swigc__p_Ogre__StreamSerialiser,
  _swigc__p_Ogre__StreamSerialiser__Chunk,
  _swigc__p_Ogre__StringConverter,
  _swigc__p_Ogre__StringInterface,
  _swigc__p_Ogre__StringUtil,
  _swigc__p_Ogre__SubEntity,
  _swigc__p_Ogre__SubMesh,
  _swigc__p_Ogre__TRectT_float_t,
  _swigc__p_Ogre__TRectT_long_t,
  _swigc__p_Ogre__TagPoint,
  _swigc__p_Ogre__TangentSpaceCalc,
  _swigc__p_Ogre__TangentSpaceCalc__Result,
  _swigc__p_Ogre__Technique,
  _swigc__p_Ogre__TechniqueTranslator,
  _swigc__p_Ogre__TempBlendedBufferInfo,
  _swigc__p_Ogre__Terrain,
  _swigc__p_Ogre__TerrainGlobalOptions,
  _swigc__p_Ogre__TerrainGroup,
  _swigc__p_Ogre__TerrainGroup__RayResult,
  _swigc__p_Ogre__TerrainGroup__TerrainSlotDefinition,
  _swigc__p_Ogre__TerrainLayerBlendMap,
  _swigc__p_Ogre__TerrainLayerDeclaration,
  _swigc__p_Ogre__TerrainLayerSampler,
  _swigc__p_Ogre__TerrainLayerSamplerElement,
  _swigc__p_Ogre__TerrainMaterialGenerator,
  _swigc__p_Ogre__TerrainMaterialGeneratorA,
  _swigc__p_Ogre__TerrainMaterialGenerator__Profile,
  _swigc__p_Ogre__TerrainPagedWorldSection,
  _swigc__p_Ogre__TerrainPaging,
  _swigc__p_Ogre__TerrainQuadTreeNode,
  _swigc__p_Ogre__TerrainQuadTreeNode__LodLevel,
  _swigc__p_Ogre__Terrain__GpuBufferAllocator,
  _swigc__p_Ogre__Terrain__ImportData,
  _swigc__p_Ogre__TexCoordModifierControllerValue,
  _swigc__p_Ogre__TextAreaOverlayElement,
  _swigc__p_Ogre__TextAreaOverlayElementFactory,
  _swigc__p_Ogre__Texture,
  _swigc__p_Ogre__TextureFrameControllerValue,
  _swigc__p_Ogre__TextureManager,
  _swigc__p_Ogre__TexturePtr,
  _swigc__p_Ogre__TextureSourceTranslator,
  _swigc__p_Ogre__TextureUnitState,
  _swigc__p_Ogre__TextureUnitState__TextureEffect,
  _swigc__p_Ogre__TextureUnitState__UVWAddressingMode,
  _swigc__p_Ogre__TextureUnitTranslator,
  _swigc__p_Ogre__TimeIndex,
  _swigc__p_Ogre__Timer,
  _swigc__p_Ogre__TransformKeyFrame,
  _swigc__p_Ogre__UTFString,
  _swigc__p_Ogre__UTFString___const_fwd_iterator,
  _swigc__p_Ogre__UTFString___const_rev_iterator,
  _swigc__p_Ogre__UTFString___fwd_iterator,
  _swigc__p_Ogre__UTFString___rev_iterator,
  _swigc__p_Ogre__UnifiedHighLevelGpuProgram,
  _swigc__p_Ogre__UnifiedHighLevelGpuProgramFactory,
  _swigc__p_Ogre__UnimplementedException,
  _swigc__p_Ogre__UserObjectBindings,
  _swigc__p_Ogre__VariableAccessAbstractNode,
  _swigc__p_Ogre__Vector2,
  _swigc__p_Ogre__Vector3,
  _swigc__p_Ogre__Vector4,
  _swigc__p_Ogre__VectorIteratorT_Ogre__listT_Ogre__OverlayContainer_p_Ogre__STLAllocatorT_Ogre__OverlayContainer_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Bone_p_Ogre__STLAllocatorT_Ogre__Bone_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionPass_p_Ogre__STLAllocatorT_Ogre__CompositionPass_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTargetPass_p_Ogre__STLAllocatorT_Ogre__CompositionTargetPass_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositionTechnique_p_Ogre__STLAllocatorT_Ogre__CompositionTechnique_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__CompositorInstance_p_Ogre__STLAllocatorT_Ogre__CompositorInstance_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__IlluminationPass_p_Ogre__STLAllocatorT_Ogre__IlluminationPass_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Pass_p_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__RenderQueueInvocation_p_Ogre__STLAllocatorT_Ogre__RenderQueueInvocation_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__ShadowRenderable_p_Ogre__STLAllocatorT_Ogre__ShadowRenderable_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__SubMesh_p_Ogre__STLAllocatorT_Ogre__SubMesh_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__Technique_p_Ogre__STLAllocatorT_Ogre__Technique_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureDefinition_p_Ogre__STLAllocatorT_Ogre__TextureDefinition_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_Ogre__TextureUnitState_p_Ogre__STLAllocatorT_Ogre__TextureUnitState_p_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VectorIteratorT_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type_t,
  _swigc__p_Ogre__VertexAnimationTrack,
  _swigc__p_Ogre__VertexBoneAssignment_s,
  _swigc__p_Ogre__VertexBufferBinding,
  _swigc__p_Ogre__VertexCacheProfiler,
  _swigc__p_Ogre__VertexData,
  _swigc__p_Ogre__VertexDeclaration,
  _swigc__p_Ogre__VertexElement,
  _swigc__p_Ogre__VertexMorphKeyFrame,
  _swigc__p_Ogre__VertexPoseKeyFrame,
  _swigc__p_Ogre__ViewPoint,
  _swigc__p_Ogre__Viewport,
  _swigc__p_Ogre__Viewport__Listener,
  _swigc__p_Ogre__VisibleObjectsBoundsInfo,
  _swigc__p_Ogre__WaveformControllerFunction,
  _swigc__p_Ogre__WindowEventListener,
  _swigc__p_Ogre__WindowEventUtilities,
  _swigc__p_Ogre__WireBoundingBox,
  _swigc__p_Ogre__WorkQueue,
  _swigc__p_Ogre__WorkQueue__Request,
  _swigc__p_Ogre__WorkQueue__RequestHandler,
  _swigc__p_Ogre__WorkQueue__Response,
  _swigc__p_Ogre__WorkQueue__ResponseHandler,
  _swigc__p_Ogre__ZipArchive,
  _swigc__p_Ogre__ZipArchiveFactory,
  _swigc__p_Ogre__ZipDataStream,
  _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__Particle_p_Ogre__STLAllocatorT_Ogre__Particle_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__Plane_Ogre__STLAllocatorT_Ogre__Plane_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__listT_Ogre__ResourceLocation_p_Ogre__STLAllocatorT_Ogre__ResourceLocation_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__VertexElement_Ogre__STLAllocatorT_Ogre__VertexElement_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__listT_ResourceDeclaration_Ogre__STLAllocatorT_ResourceDeclaration_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__GpuSharedParametersPtr_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__GpuSharedParametersPtr_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__OverlayElementFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__OverlayElementFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__PageContentCollectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentCollectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__PageContentFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageContentFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__PageStrategy_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PageStrategy_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSectionFactory_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSectionFactory_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__PagedWorldSection_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorldSection_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_Ogre__String_Ogre__PagedWorld_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__PagedWorld_p_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__RenderSystemCapabilities_p_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_const_Ogre__RenderSystemCapabilities_p_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_Ogre__ushort_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_std__pairT_Ogre__ushort_const_Ogre__ushort_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__mapT_size_t_Ogre__Vector3_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__Vector3_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_unsigned_short_Ogre__HardwareVertexBufferSharedPtr_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__HardwareVertexBufferSharedPtr_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_unsigned_short_Ogre__NodeAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NodeAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_unsigned_short_Ogre__NumericAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__NumericAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__mapT_unsigned_short_Ogre__VertexAnimationTrack_p_std__lessT_unsigned_short_t_Ogre__STLAllocatorT_std__pairT_unsigned_short_const_Ogre__VertexAnimationTrack_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__multimapT_Ogre__RenderWindow_p_Ogre__WindowEventListener_p_std__lessT_Ogre__RenderWindow_p_t_Ogre__STLAllocatorT_std__pairT_Ogre__RenderWindow_pconst_Ogre__WindowEventListener_p_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__multimapT_Ogre__TextureUnitState__TextureEffectType_Ogre__TextureEffect_std__lessT_Ogre__TextureUnitState__TextureEffectType_t_Ogre__STLAllocatorT_std__pairT_Ogre__TextureUnitState__TextureEffectType_const_Ogre__TextureEffect_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__multimapT_Ogre__Vector3_Ogre__Vector3_std__lessT_Ogre__Vector3_t_Ogre__STLAllocatorT_std__pairT_Ogre__Vector3_const_Ogre__Vector3_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__multimapT_size_t_Ogre__VertexBoneAssignment_std__lessT_size_t_t_Ogre__STLAllocatorT_std__pairT_size_t_const_Ogre__VertexBoneAssignment_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__setT_Ogre__Entity_p_std__lessT_Ogre__Entity_p_t_Ogre__STLAllocatorT_Ogre__Entity_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__setT_Ogre__Pass_p_std__lessT_Ogre__Pass_p_t_Ogre__STLAllocatorT_Ogre__Pass_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__setT_Ogre__SceneQuery__WorldFragmentType_std__lessT_Ogre__SceneQuery__WorldFragmentType_t_Ogre__STLAllocatorT_Ogre__SceneQuery__WorldFragmentType_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__setT_Ogre__String_std__lessT_Ogre__String_t_Ogre__STLAllocatorT_Ogre__String_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__setT_Ogre__Texture_p_std__lessT_Ogre__Texture_p_t_Ogre__STLAllocatorT_Ogre__Texture_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__setT_Ogre__ushort_std__lessT_Ogre__ushort_t_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_AutoConstantEntry_Ogre__STLAllocatorT_AutoConstantEntry_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_LayerInstance_Ogre__STLAllocatorT_LayerInstance_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Camera_p_Ogre__STLAllocatorT_Ogre__Camera_p_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__EdgeGroup_Ogre__STLAllocatorT_Ogre__EdgeGroup_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__Font__CodePointRange_Ogre__STLAllocatorT_Ogre__Font__CodePointRange_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__GpuSharedParametersUsage_Ogre__STLAllocatorT_Ogre__GpuSharedParametersUsage_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__HardwareAnimationData_Ogre__STLAllocatorT_Ogre__HardwareAnimationData_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__IndexData_p_Ogre__STLAllocatorT_Ogre__IndexData_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__InstancedEntity_p_Ogre__STLAllocatorT_Ogre__InstancedEntity_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__MeshLodUsage_Ogre__STLAllocatorT_Ogre__MeshLodUsage_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__PageContentCollection_p_Ogre__STLAllocatorT_Ogre__PageContentCollection_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__PageContent_p_Ogre__STLAllocatorT_Ogre__PageContent_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__Plugin_p_Ogre__STLAllocatorT_Ogre__Plugin_p_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__Profile_p_Ogre__STLAllocatorT_Ogre__Profile_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__Real_Ogre__STLAllocatorT_Ogre__Real_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__RenderOperation_p_Ogre__STLAllocatorT_Ogre__RenderOperation_p_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__RenderTexture_p_Ogre__STLAllocatorT_Ogre__RenderTexture_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__TargetOperation_Ogre__STLAllocatorT_Ogre__TargetOperation_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__Terrain_p_Ogre__STLAllocatorT_Ogre__Terrain_p_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__TexturePtr_Ogre__STLAllocatorT_Ogre__TexturePtr_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Triangle_Ogre__STLAllocatorT_Ogre__Triangle_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Vector3_Ogre__STLAllocatorT_Ogre__Vector3_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__Vector4_Ogre__STLAllocatorT_Ogre__Vector4_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_Ogre__ushort_Ogre__STLAllocatorT_Ogre__ushort_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_PoseRef_Ogre__STLAllocatorT_PoseRef_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_char_Ogre__STLAllocatorT_char_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_Ogre__vectorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__STLAllocatorT_std__pairT_Ogre__String_Ogre__String_t_Ogre__GeneralAllocPolicy_t_t__type,
  _swigc__p_Ogre__vectorT_unsigned_short_Ogre__STLAllocatorT_unsigned_short_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_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_ResourcePool,
  _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_a_3__float,
  _swigc__p_bool,
  _swigc__p_char,
  _swigc__p_code_point,
  _swigc__p_const_iterator,
  _swigc__p_const_reverse_iterator,
  _swigc__p_double,
  _swigc__p_dstring,
  _swigc__p_f_size_t_p_void_size_t__bool,
  _swigc__p_float,
  _swigc__p_int,
  _swigc__p_iterator,
  _swigc__p_long,
  _swigc__p_long_long,
  _swigc__p_p_Ogre__KeyFrame,
  _swigc__p_p_Ogre__LinkedSkeletonAnimationSource,
  _swigc__p_p_Ogre__Matrix4,
  _swigc__p_p_Ogre__NumericKeyFrame,
  _swigc__p_p_Ogre__Terrain,
  _swigc__p_p_Ogre__TransformKeyFrame,
  _swigc__p_p_Ogre__VertexMorphKeyFrame,
  _swigc__p_p_Ogre__VertexPoseKeyFrame,
  _swigc__p_p_char,
  _swigc__p_p_float,
  _swigc__p_p_unsigned_char,
  _swigc__p_p_unsigned_int,
  _swigc__p_p_unsigned_short,
  _swigc__p_p_void,
  _swigc__p_reverse_iterator,
  _swigc__p_short,
  _swigc__p_size_t,
  _swigc__p_size_type,
  _swigc__p_std__basic_stringT_unsigned_int_t,
  _swigc__p_std__basic_stringstreamT_char_std__char_traitsT_char_t_std__allocatorT_char_t_t,
  _swigc__p_std__exception,
  _swigc__p_std__fstream,
  _swigc__p_std__ifstream,
  _swigc__p_std__ios__fmtflags,
  _swigc__p_std__ostream,
  _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__pairT_Ogre__SharedPtrT_Ogre__MemoryDataStream_t_Ogre__SharedPtrT_Ogre__CodecData_t_t,
  _swigc__p_std__pairT_Ogre__SharedPtrT_Ogre__Resource_t_bool_t,
  _swigc__p_std__pairT_bool_Ogre__Vector3_t,
  _swigc__p_std__pairT_bool_float_t,
  _swigc__p_std__pairT_bool_std__string_t,
  _swigc__p_std__pairT_size_t_size_t_t,
  _swigc__p_std__pairT_unsigned_char_unsigned_char_t,
  _swigc__p_std__pairT_unsigned_int_unsigned_int_t,
  _swigc__p_std__string,
  _swigc__p_std__tr1__unordered_mapT_Ogre__String_Ogre__ushort_t,
  _swigc__p_std__type_info,
  _swigc__p_std__vectorT_Ogre__Vector4_STLAllocatorT_Ogre__Vector4_Ogre__CategorisedAlignAllocPolicyT_Ogre__MEMCATEGORY_GEOMETRY_0_t_t_t,
  _swigc__p_std__vectorT_std__string_std__allocatorT_std__string_t_t,
  _swigc__p_std__wostream,
  _swigc__p_std__wstring,
  _swigc__p_stdext__hash_compareT_Ogre___StringBase_std__lessT_Ogre___StringBase_t_t,
  _swigc__p_swig__ConstIterator,
  _swigc__p_swig__GC_VALUE,
  _swigc__p_swig__Iterator,
  _swigc__p_time_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_void,
  _swigc__p_wchar_t,
  _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_Ogre(void) {
  size_t i;
  
  SWIG_InitRuntime();
  mOgre = rb_define_module("Ogre");
  
  SWIG_InitializeModule(0);
  for (i = 0; i < swig_module.size; i++) {
    SWIG_define_class(swig_module.types[i]);
  }
  
  SWIG_RubyInitializeTrackings();
  
  SwigClassIntp.klass = rb_define_class_under(mOgre, "Intp", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Intp, (void *) &SwigClassIntp);
  rb_define_alloc_func(SwigClassIntp.klass, _wrap_Intp_allocate);
  rb_define_method(SwigClassIntp.klass, "initialize", VALUEFUNC(_wrap_new_Intp), -1);
  rb_define_method(SwigClassIntp.klass, "assign", VALUEFUNC(_wrap_Intp_assign), -1);
  rb_define_method(SwigClassIntp.klass, "value", VALUEFUNC(_wrap_Intp_value), -1);
  rb_define_method(SwigClassIntp.klass, "cast", VALUEFUNC(_wrap_Intp_cast), -1);
  rb_define_singleton_method(SwigClassIntp.klass, "frompointer", VALUEFUNC(_wrap_Intp_frompointer), -1);
  SwigClassIntp.mark = 0;
  SwigClassIntp.destroy = (void (*)(void *)) free_Intp;
  SwigClassIntp.trackObjects = 0;
  
  SwigClassGC_VALUE.klass = rb_define_class_under(mOgre, "GC_VALUE", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_swig__GC_VALUE, (void *) &SwigClassGC_VALUE);
  rb_undef_alloc_func(SwigClassGC_VALUE.klass);
  rb_define_method(SwigClassGC_VALUE.klass, "inspect", VALUEFUNC(_wrap_GC_VALUE_inspect), -1);
  rb_define_method(SwigClassGC_VALUE.klass, "to_s", VALUEFUNC(_wrap_GC_VALUE_to_s), -1);
  SwigClassGC_VALUE.mark = 0;
  SwigClassGC_VALUE.trackObjects = 0;
  
  swig::GC_VALUE::initialize();
  
  
  SwigClassConstIterator.klass = rb_define_class_under(mOgre, "ConstIterator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_swig__ConstIterator, (void *) &SwigClassConstIterator);
  rb_undef_alloc_func(SwigClassConstIterator.klass);
  rb_define_method(SwigClassConstIterator.klass, "value", VALUEFUNC(_wrap_ConstIterator_value), -1);
  rb_define_method(SwigClassConstIterator.klass, "dup", VALUEFUNC(_wrap_ConstIterator_dup), -1);
  rb_define_method(SwigClassConstIterator.klass, "inspect", VALUEFUNC(_wrap_ConstIterator_inspect), -1);
  rb_define_method(SwigClassConstIterator.klass, "to_s", VALUEFUNC(_wrap_ConstIterator_to_s), -1);
  rb_define_method(SwigClassConstIterator.klass, "next", VALUEFUNC(_wrap_ConstIterator_next), -1);
  rb_define_method(SwigClassConstIterator.klass, "previous", VALUEFUNC(_wrap_ConstIterator_previous), -1);
  rb_define_method(SwigClassConstIterator.klass, "==", VALUEFUNC(_wrap_ConstIterator___eq__), -1);
  rb_define_method(SwigClassConstIterator.klass, "+", VALUEFUNC(_wrap_ConstIterator___add__), -1);
  rb_define_method(SwigClassConstIterator.klass, "-", VALUEFUNC(_wrap_ConstIterator___sub__), -1);
  SwigClassConstIterator.mark = 0;
  SwigClassConstIterator.destroy = (void (*)(void *)) free_swig_ConstIterator;
  SwigClassConstIterator.trackObjects = 0;
  
  SwigClassIterator.klass = rb_define_class_under(mOgre, "Iterator", ((swig_class *) SWIGTYPE_p_swig__ConstIterator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_swig__Iterator, (void *) &SwigClassIterator);
  rb_undef_alloc_func(SwigClassIterator.klass);
  rb_define_method(SwigClassIterator.klass, "value=", VALUEFUNC(_wrap_Iterator_valuee___), -1);
  rb_define_method(SwigClassIterator.klass, "dup", VALUEFUNC(_wrap_Iterator_dup), -1);
  rb_define_method(SwigClassIterator.klass, "next", VALUEFUNC(_wrap_Iterator_next), -1);
  rb_define_method(SwigClassIterator.klass, "previous", VALUEFUNC(_wrap_Iterator_previous), -1);
  rb_define_method(SwigClassIterator.klass, "inspect", VALUEFUNC(_wrap_Iterator_inspect), -1);
  rb_define_method(SwigClassIterator.klass, "to_s", VALUEFUNC(_wrap_Iterator_to_s), -1);
  rb_define_method(SwigClassIterator.klass, "==", VALUEFUNC(_wrap_Iterator___eq__), -1);
  rb_define_method(SwigClassIterator.klass, "+", VALUEFUNC(_wrap_Iterator___add__), -1);
  rb_define_method(SwigClassIterator.klass, "-", VALUEFUNC(_wrap_Iterator___sub__), -1);
  SwigClassIterator.mark = 0;
  SwigClassIterator.destroy = (void (*)(void *)) free_swig_Iterator;
  SwigClassIterator.trackObjects = 0;
  rb_define_const(mOgre, "OGRE_MEMORY_TRACKER", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_VERSION_MAJOR", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_VERSION_MINOR", SWIG_From_int(static_cast< int >(8)));
  rb_define_const(mOgre, "OGRE_VERSION_PATCH", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_VERSION_SUFFIX", SWIG_FromCharPtr(""));
  rb_define_const(mOgre, "OGRE_VERSION_NAME", SWIG_FromCharPtr("Byatis"));
  rb_define_const(mOgre, "OGRE_VERSION", SWIG_From_int(static_cast< int >(((1 << 16)|(8 << 8)|0))));
  rb_define_const(mOgre, "OGRE_DOUBLE_PRECISION", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_MEMORY_ALLOCATOR", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_CONTAINERS_USE_CUSTOM_MEMORY_ALLOCATOR", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_STRING_USE_CUSTOM_MEMORY_ALLOCATOR", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_MEMORY_TRACKER_DEBUG_MODE", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_MEMORY_TRACKER_RELEASE_MODE", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_THREAD_SUPPORT", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_THREAD_PROVIDER", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_NO_FREEIMAGE", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_NO_DDS_CODEC", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_NO_PVRTC_CODEC", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_NO_ZIP_ARCHIVE", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_NO_VIEWPORT_ORIENTATIONMODE", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_NO_GLES2_CG_SUPPORT", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_NO_GLES2_GLSL_OPTIMISER", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_USE_NEW_COMPILERS", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_USE_BOOST", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_PROFILING", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_ASSERT_MODE", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_PRETEND_TEXTURE_UNITS", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_MAX_TEXTURE_COORD_SETS", SWIG_From_int(static_cast< int >(8)));
  rb_define_const(mOgre, "OGRE_MAX_TEXTURE_LAYERS", SWIG_From_int(static_cast< int >(16)));
  rb_define_const(mOgre, "OGRE_MAX_SIMULTANEOUS_LIGHTS", SWIG_From_int(static_cast< int >(8)));
  rb_define_const(mOgre, "OGRE_MAX_BLEND_WEIGHTS", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_MEMORY_ALLOCATOR_STD", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_MEMORY_ALLOCATOR_NED", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mOgre, "OGRE_MEMORY_ALLOCATOR_USER", SWIG_From_int(static_cast< int >(3)));
  rb_define_const(mOgre, "OGRE_MEMORY_ALLOCATOR_NEDPOOLING", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_MAX_MULTIPLE_RENDER_TARGETS", SWIG_From_int(static_cast< int >(8)));
  rb_define_const(mOgre, "OGRE_PLATFORM_WIN32", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_PLATFORM_LINUX", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mOgre, "OGRE_PLATFORM_APPLE", SWIG_From_int(static_cast< int >(3)));
  rb_define_const(mOgre, "OGRE_PLATFORM_SYMBIAN", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_PLATFORM_APPLE_IOS", SWIG_From_int(static_cast< int >(5)));
  rb_define_const(mOgre, "OGRE_PLATFORM_ANDROID", SWIG_From_int(static_cast< int >(6)));
  rb_define_const(mOgre, "OGRE_PLATFORM_NACL", SWIG_From_int(static_cast< int >(7)));
  rb_define_const(mOgre, "OGRE_COMPILER_MSVC", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_COMPILER_GNUC", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mOgre, "OGRE_COMPILER_BORL", SWIG_From_int(static_cast< int >(3)));
  rb_define_const(mOgre, "OGRE_COMPILER_WINSCW", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_COMPILER_GCCE", SWIG_From_int(static_cast< int >(5)));
  rb_define_const(mOgre, "OGRE_COMPILER_CLANG", SWIG_From_int(static_cast< int >(6)));
  rb_define_const(mOgre, "OGRE_ENDIAN_LITTLE", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_ENDIAN_BIG", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mOgre, "OGRE_ARCHITECTURE_32", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_ARCHITECTURE_64", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mOgre, "OGRE_PLATFORM", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mOgre, "OGRE_ARCH_TYPE", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_DEBUG_MODE", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_PLATFORM_LIB", SWIG_FromCharPtr("libOgrePlatform.so"));
  rb_define_const(mOgre, "OGRE_UNICODE_SUPPORT", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_ENDIAN", SWIG_From_int(static_cast< int >(1)));
  
  SwigClassVertexBoneAssignment.klass = rb_define_class_under(mOgre, "VertexBoneAssignment", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexBoneAssignment_s, (void *) &SwigClassVertexBoneAssignment);
  rb_define_alloc_func(SwigClassVertexBoneAssignment.klass, _wrap_VertexBoneAssignment_allocate);
  rb_define_method(SwigClassVertexBoneAssignment.klass, "initialize", VALUEFUNC(_wrap_new_VertexBoneAssignment), -1);
  rb_define_method(SwigClassVertexBoneAssignment.klass, "vertexIndex=", VALUEFUNC(_wrap_VertexBoneAssignment_vertexIndex_set), -1);
  rb_define_method(SwigClassVertexBoneAssignment.klass, "vertexIndex", VALUEFUNC(_wrap_VertexBoneAssignment_vertexIndex_get), -1);
  rb_define_method(SwigClassVertexBoneAssignment.klass, "boneIndex=", VALUEFUNC(_wrap_VertexBoneAssignment_boneIndex_set), -1);
  rb_define_method(SwigClassVertexBoneAssignment.klass, "boneIndex", VALUEFUNC(_wrap_VertexBoneAssignment_boneIndex_get), -1);
  rb_define_method(SwigClassVertexBoneAssignment.klass, "weight=", VALUEFUNC(_wrap_VertexBoneAssignment_weight_set), -1);
  rb_define_method(SwigClassVertexBoneAssignment.klass, "weight", VALUEFUNC(_wrap_VertexBoneAssignment_weight_get), -1);
  SwigClassVertexBoneAssignment.mark = 0;
  SwigClassVertexBoneAssignment.destroy = (void (*)(void *)) free_Ogre_VertexBoneAssignment;
  SwigClassVertexBoneAssignment.trackObjects = 0;
  
  SwigClassAlignedMemory.klass = rb_define_class_under(mOgre, "AlignedMemory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AlignedMemory, (void *) &SwigClassAlignedMemory);
  rb_define_alloc_func(SwigClassAlignedMemory.klass, _wrap_AlignedMemory_allocate);
  rb_define_method(SwigClassAlignedMemory.klass, "initialize", VALUEFUNC(_wrap_new_AlignedMemory), -1);
  rb_define_singleton_method(SwigClassAlignedMemory.klass, "deallocate", VALUEFUNC(_wrap_AlignedMemory_deallocate), -1);
  SwigClassAlignedMemory.mark = 0;
  SwigClassAlignedMemory.destroy = (void (*)(void *)) free_Ogre_AlignedMemory;
  SwigClassAlignedMemory.trackObjects = 0;
  rb_define_const(mOgre, "MEMCATEGORY_GENERAL", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_GENERAL)));
  rb_define_const(mOgre, "MEMCATEGORY_GEOMETRY", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_GEOMETRY)));
  rb_define_const(mOgre, "MEMCATEGORY_ANIMATION", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_ANIMATION)));
  rb_define_const(mOgre, "MEMCATEGORY_SCENE_CONTROL", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_SCENE_CONTROL)));
  rb_define_const(mOgre, "MEMCATEGORY_SCENE_OBJECTS", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_SCENE_OBJECTS)));
  rb_define_const(mOgre, "MEMCATEGORY_RESOURCE", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_RESOURCE)));
  rb_define_const(mOgre, "MEMCATEGORY_SCRIPTING", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_SCRIPTING)));
  rb_define_const(mOgre, "MEMCATEGORY_RENDERSYS", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_RENDERSYS)));
  rb_define_const(mOgre, "MEMCATEGORY_COUNT", SWIG_From_int(static_cast< int >(Ogre::MEMCATEGORY_COUNT)));
  
  SwigClassRadian.klass = rb_define_class_under(mOgre, "Radian", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Radian, (void *) &SwigClassRadian);
  rb_define_alloc_func(SwigClassRadian.klass, _wrap_Radian_allocate);
  rb_define_method(SwigClassRadian.klass, "initialize", VALUEFUNC(_wrap_new_Radian), -1);
  rb_define_method(SwigClassRadian.klass, "valueDegrees", VALUEFUNC(_wrap_Radian_valueDegrees), -1);
  rb_define_method(SwigClassRadian.klass, "valueRadians", VALUEFUNC(_wrap_Radian_valueRadians), -1);
  rb_define_method(SwigClassRadian.klass, "valueAngleUnits", VALUEFUNC(_wrap_Radian_valueAngleUnits), -1);
  rb_define_method(SwigClassRadian.klass, "+@", VALUEFUNC(_wrap_Radian___pos__), -1);
  rb_define_method(SwigClassRadian.klass, "+", VALUEFUNC(_wrap_Radian___add__), -1);
  rb_define_method(SwigClassRadian.klass, "-@", VALUEFUNC(_wrap_Radian___neg__), -1);
  rb_define_method(SwigClassRadian.klass, "-", VALUEFUNC(_wrap_Radian___sub__), -1);
  rb_define_method(SwigClassRadian.klass, "*", VALUEFUNC(_wrap_Radian___mul__), -1);
  rb_define_method(SwigClassRadian.klass, "/", VALUEFUNC(_wrap_Radian___div__), -1);
  rb_define_method(SwigClassRadian.klass, "<", VALUEFUNC(_wrap_Radian___lt__), -1);
  rb_define_method(SwigClassRadian.klass, "<=", VALUEFUNC(_wrap_Radian___le__), -1);
  rb_define_method(SwigClassRadian.klass, "==", VALUEFUNC(_wrap_Radian___eq__), -1);
  rb_define_method(SwigClassRadian.klass, ">=", VALUEFUNC(_wrap_Radian___ge__), -1);
  rb_define_method(SwigClassRadian.klass, ">", VALUEFUNC(_wrap_Radian___gt__), -1);
  SwigClassRadian.mark = 0;
  SwigClassRadian.destroy = (void (*)(void *)) free_Ogre_Radian;
  SwigClassRadian.trackObjects = 0;
  
  SwigClassDegree.klass = rb_define_class_under(mOgre, "Degree", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Degree, (void *) &SwigClassDegree);
  rb_define_alloc_func(SwigClassDegree.klass, _wrap_Degree_allocate);
  rb_define_method(SwigClassDegree.klass, "initialize", VALUEFUNC(_wrap_new_Degree), -1);
  rb_define_method(SwigClassDegree.klass, "valueDegrees", VALUEFUNC(_wrap_Degree_valueDegrees), -1);
  rb_define_method(SwigClassDegree.klass, "valueRadians", VALUEFUNC(_wrap_Degree_valueRadians), -1);
  rb_define_method(SwigClassDegree.klass, "valueAngleUnits", VALUEFUNC(_wrap_Degree_valueAngleUnits), -1);
  rb_define_method(SwigClassDegree.klass, "+@", VALUEFUNC(_wrap_Degree___pos__), -1);
  rb_define_method(SwigClassDegree.klass, "+", VALUEFUNC(_wrap_Degree___add__), -1);
  rb_define_method(SwigClassDegree.klass, "-@", VALUEFUNC(_wrap_Degree___neg__), -1);
  rb_define_method(SwigClassDegree.klass, "-", VALUEFUNC(_wrap_Degree___sub__), -1);
  rb_define_method(SwigClassDegree.klass, "*", VALUEFUNC(_wrap_Degree___mul__), -1);
  rb_define_method(SwigClassDegree.klass, "/", VALUEFUNC(_wrap_Degree___div__), -1);
  rb_define_method(SwigClassDegree.klass, "<", VALUEFUNC(_wrap_Degree___lt__), -1);
  rb_define_method(SwigClassDegree.klass, "<=", VALUEFUNC(_wrap_Degree___le__), -1);
  rb_define_method(SwigClassDegree.klass, "==", VALUEFUNC(_wrap_Degree___eq__), -1);
  rb_define_method(SwigClassDegree.klass, ">=", VALUEFUNC(_wrap_Degree___ge__), -1);
  rb_define_method(SwigClassDegree.klass, ">", VALUEFUNC(_wrap_Degree___gt__), -1);
  SwigClassDegree.mark = 0;
  SwigClassDegree.destroy = (void (*)(void *)) free_Ogre_Degree;
  SwigClassDegree.trackObjects = 0;
  
  SwigClassAngle.klass = rb_define_class_under(mOgre, "Angle", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Angle, (void *) &SwigClassAngle);
  rb_define_alloc_func(SwigClassAngle.klass, _wrap_Angle_allocate);
  rb_define_method(SwigClassAngle.klass, "initialize", VALUEFUNC(_wrap_new_Angle), -1);
  SwigClassAngle.mark = 0;
  SwigClassAngle.destroy = (void (*)(void *)) free_Ogre_Angle;
  SwigClassAngle.trackObjects = 0;
  
  SwigClassMath.klass = rb_define_class_under(mOgre, "Math", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Math, (void *) &SwigClassMath);
  rb_define_alloc_func(SwigClassMath.klass, _wrap_Math_allocate);
  rb_define_method(SwigClassMath.klass, "initialize", VALUEFUNC(_wrap_new_Math), -1);
  rb_define_const(SwigClassMath.klass, "AU_DEGREE", SWIG_From_int(static_cast< int >(Ogre::Math::AU_DEGREE)));
  rb_define_const(SwigClassMath.klass, "AU_RADIAN", SWIG_From_int(static_cast< int >(Ogre::Math::AU_RADIAN)));
  rb_define_singleton_method(SwigClassMath.klass, "IAbs", VALUEFUNC(_wrap_Math_IAbs), -1);
  rb_define_singleton_method(SwigClassMath.klass, "ICeil", VALUEFUNC(_wrap_Math_ICeil), -1);
  rb_define_singleton_method(SwigClassMath.klass, "IFloor", VALUEFUNC(_wrap_Math_IFloor), -1);
  rb_define_singleton_method(SwigClassMath.klass, "ISign", VALUEFUNC(_wrap_Math_ISign), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Abs", VALUEFUNC(_wrap_Math_Abs), -1);
  rb_define_singleton_method(SwigClassMath.klass, "ACos", VALUEFUNC(_wrap_Math_ACos), -1);
  rb_define_singleton_method(SwigClassMath.klass, "ASin", VALUEFUNC(_wrap_Math_ASin), -1);
  rb_define_singleton_method(SwigClassMath.klass, "ATan", VALUEFUNC(_wrap_Math_ATan), -1);
  rb_define_singleton_method(SwigClassMath.klass, "ATan2", VALUEFUNC(_wrap_Math_ATan2), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Ceil", VALUEFUNC(_wrap_Math_Ceil), -1);
  rb_define_singleton_method(SwigClassMath.klass, "isNaN", VALUEFUNC(_wrap_Math_isNaN), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Cos", VALUEFUNC(_wrap_Math_Cos), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Exp", VALUEFUNC(_wrap_Math_Exp), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Floor", VALUEFUNC(_wrap_Math_Floor), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Log", VALUEFUNC(_wrap_Math_Log), -1);
  rb_define_singleton_method(SwigClassMath.klass, "LOG2", VALUEFUNC(_wrap_Math_LOG2_get), 0);
  rb_define_singleton_method(SwigClassMath.klass, "Log2", VALUEFUNC(_wrap_Math_Log2), -1);
  rb_define_singleton_method(SwigClassMath.klass, "LogN", VALUEFUNC(_wrap_Math_LogN), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Pow", VALUEFUNC(_wrap_Math_Pow), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Sign", VALUEFUNC(_wrap_Math_Sign), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Sin", VALUEFUNC(_wrap_Math_Sin), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Sqr", VALUEFUNC(_wrap_Math_Sqr), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Sqrt", VALUEFUNC(_wrap_Math_Sqrt), -1);
  rb_define_singleton_method(SwigClassMath.klass, "InvSqrt", VALUEFUNC(_wrap_Math_InvSqrt), -1);
  rb_define_singleton_method(SwigClassMath.klass, "UnitRandom", VALUEFUNC(_wrap_Math_UnitRandom), -1);
  rb_define_singleton_method(SwigClassMath.klass, "RangeRandom", VALUEFUNC(_wrap_Math_RangeRandom), -1);
  rb_define_singleton_method(SwigClassMath.klass, "SymmetricRandom", VALUEFUNC(_wrap_Math_SymmetricRandom), -1);
  rb_define_singleton_method(SwigClassMath.klass, "Tan", VALUEFUNC(_wrap_Math_Tan), -1);
  rb_define_singleton_method(SwigClassMath.klass, "DegreesToRadians", VALUEFUNC(_wrap_Math_DegreesToRadians), -1);
  rb_define_singleton_method(SwigClassMath.klass, "RadiansToDegrees", VALUEFUNC(_wrap_Math_RadiansToDegrees), -1);
  rb_define_singleton_method(SwigClassMath.klass, "setAngleUnit", VALUEFUNC(_wrap_Math_setAngleUnit), -1);
  rb_define_singleton_method(SwigClassMath.klass, "getAngleUnit", VALUEFUNC(_wrap_Math_getAngleUnit), -1);
  rb_define_singleton_method(SwigClassMath.klass, "AngleUnitsToRadians", VALUEFUNC(_wrap_Math_AngleUnitsToRadians), -1);
  rb_define_singleton_method(SwigClassMath.klass, "RadiansToAngleUnits", VALUEFUNC(_wrap_Math_RadiansToAngleUnits), -1);
  rb_define_singleton_method(SwigClassMath.klass, "AngleUnitsToDegrees", VALUEFUNC(_wrap_Math_AngleUnitsToDegrees), -1);
  rb_define_singleton_method(SwigClassMath.klass, "DegreesToAngleUnits", VALUEFUNC(_wrap_Math_DegreesToAngleUnits), -1);
  rb_define_singleton_method(SwigClassMath.klass, "pointInTri2D", VALUEFUNC(_wrap_Math_pointInTri2D), -1);
  rb_define_singleton_method(SwigClassMath.klass, "pointInTri3D", VALUEFUNC(_wrap_Math_pointInTri3D), -1);
  rb_define_singleton_method(SwigClassMath.klass, "intersects", VALUEFUNC(_wrap_Math_intersects), -1);
  rb_define_singleton_method(SwigClassMath.klass, "RealEqual", VALUEFUNC(_wrap_Math_RealEqual), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculateTangentSpaceVector", VALUEFUNC(_wrap_Math_calculateTangentSpaceVector), -1);
  rb_define_singleton_method(SwigClassMath.klass, "buildReflectionMatrix", VALUEFUNC(_wrap_Math_buildReflectionMatrix), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculateFaceNormal", VALUEFUNC(_wrap_Math_calculateFaceNormal), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculateBasicFaceNormal", VALUEFUNC(_wrap_Math_calculateBasicFaceNormal), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculateFaceNormalWithoutNormalize", VALUEFUNC(_wrap_Math_calculateFaceNormalWithoutNormalize), -1);
  rb_define_singleton_method(SwigClassMath.klass, "calculateBasicFaceNormalWithoutNormalize", VALUEFUNC(_wrap_Math_calculateBasicFaceNormalWithoutNormalize), -1);
  rb_define_singleton_method(SwigClassMath.klass, "gaussianDistribution", VALUEFUNC(_wrap_Math_gaussianDistribution), -1);
  rb_define_singleton_method(SwigClassMath.klass, "makeViewMatrix", VALUEFUNC(_wrap_Math_makeViewMatrix), -1);
  rb_define_singleton_method(SwigClassMath.klass, "boundingRadiusFromAABB", VALUEFUNC(_wrap_Math_boundingRadiusFromAABB), -1);
  rb_define_singleton_method(SwigClassMath.klass, "POS_INFINITY", VALUEFUNC(_wrap_Math_POS_INFINITY_get), 0);
  rb_define_singleton_method(SwigClassMath.klass, "NEG_INFINITY", VALUEFUNC(_wrap_Math_NEG_INFINITY_get), 0);
  rb_define_singleton_method(SwigClassMath.klass, "PI", VALUEFUNC(_wrap_Math_PI_get), 0);
  rb_define_singleton_method(SwigClassMath.klass, "TWO_PI", VALUEFUNC(_wrap_Math_TWO_PI_get), 0);
  rb_define_singleton_method(SwigClassMath.klass, "HALF_PI", VALUEFUNC(_wrap_Math_HALF_PI_get), 0);
  rb_define_singleton_method(SwigClassMath.klass, "fDeg2Rad", VALUEFUNC(_wrap_Math_fDeg2Rad_get), 0);
  rb_define_singleton_method(SwigClassMath.klass, "fRad2Deg", VALUEFUNC(_wrap_Math_fRad2Deg_get), 0);
  SwigClassMath.mark = 0;
  SwigClassMath.destroy = (void (*)(void *)) free_Ogre_Math;
  SwigClassMath.trackObjects = 0;
  rb_define_module_function(mOgre, "/", VALUEFUNC(_wrap___div__), -1);
  
  SwigClassVector2.klass = rb_define_class_under(mOgre, "Vector2", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Vector2, (void *) &SwigClassVector2);
  rb_define_alloc_func(SwigClassVector2.klass, _wrap_Vector2_allocate);
  rb_define_method(SwigClassVector2.klass, "initialize", VALUEFUNC(_wrap_new_Vector2), -1);
  rb_define_method(SwigClassVector2.klass, "x=", VALUEFUNC(_wrap_Vector2_x_set), -1);
  rb_define_method(SwigClassVector2.klass, "x", VALUEFUNC(_wrap_Vector2_x_get), -1);
  rb_define_method(SwigClassVector2.klass, "y=", VALUEFUNC(_wrap_Vector2_y_set), -1);
  rb_define_method(SwigClassVector2.klass, "y", VALUEFUNC(_wrap_Vector2_y_get), -1);
  rb_define_method(SwigClassVector2.klass, "swap", VALUEFUNC(_wrap_Vector2_swap), -1);
  rb_define_method(SwigClassVector2.klass, "ptr", VALUEFUNC(_wrap_Vector2_ptr), -1);
  rb_define_method(SwigClassVector2.klass, "==", VALUEFUNC(_wrap_Vector2___eq__), -1);
  rb_define_method(SwigClassVector2.klass, "+", VALUEFUNC(_wrap_Vector2___add__), -1);
  rb_define_method(SwigClassVector2.klass, "-", VALUEFUNC(_wrap_Vector2___sub__), -1);
  rb_define_method(SwigClassVector2.klass, "*", VALUEFUNC(_wrap_Vector2___mul__), -1);
  rb_define_method(SwigClassVector2.klass, "/", VALUEFUNC(_wrap_Vector2___div__), -1);
  rb_define_method(SwigClassVector2.klass, "+@", VALUEFUNC(_wrap_Vector2___pos__), -1);
  rb_define_method(SwigClassVector2.klass, "-@", VALUEFUNC(_wrap_Vector2___neg__), -1);
  rb_define_method(SwigClassVector2.klass, "length", VALUEFUNC(_wrap_Vector2_length), -1);
  rb_define_method(SwigClassVector2.klass, "squaredLength", VALUEFUNC(_wrap_Vector2_squaredLength), -1);
  rb_define_method(SwigClassVector2.klass, "distance", VALUEFUNC(_wrap_Vector2_distance), -1);
  rb_define_method(SwigClassVector2.klass, "squaredDistance", VALUEFUNC(_wrap_Vector2_squaredDistance), -1);
  rb_define_method(SwigClassVector2.klass, "dotProduct", VALUEFUNC(_wrap_Vector2_dotProduct), -1);
  rb_define_method(SwigClassVector2.klass, "normalise", VALUEFUNC(_wrap_Vector2_normalise), -1);
  rb_define_method(SwigClassVector2.klass, "midPoint", VALUEFUNC(_wrap_Vector2_midPoint), -1);
  rb_define_method(SwigClassVector2.klass, "<", VALUEFUNC(_wrap_Vector2___lt__), -1);
  rb_define_method(SwigClassVector2.klass, ">", VALUEFUNC(_wrap_Vector2___gt__), -1);
  rb_define_method(SwigClassVector2.klass, "makeFloor", VALUEFUNC(_wrap_Vector2_makeFloor), -1);
  rb_define_method(SwigClassVector2.klass, "makeCeil", VALUEFUNC(_wrap_Vector2_makeCeil), -1);
  rb_define_method(SwigClassVector2.klass, "perpendicular", VALUEFUNC(_wrap_Vector2_perpendicular), -1);
  rb_define_method(SwigClassVector2.klass, "crossProduct", VALUEFUNC(_wrap_Vector2_crossProduct), -1);
  rb_define_method(SwigClassVector2.klass, "randomDeviant", VALUEFUNC(_wrap_Vector2_randomDeviant), -1);
  rb_define_method(SwigClassVector2.klass, "isZeroLength", VALUEFUNC(_wrap_Vector2_isZeroLength), -1);
  rb_define_method(SwigClassVector2.klass, "normalisedCopy", VALUEFUNC(_wrap_Vector2_normalisedCopy), -1);
  rb_define_method(SwigClassVector2.klass, "reflect", VALUEFUNC(_wrap_Vector2_reflect), -1);
  rb_define_method(SwigClassVector2.klass, "isNaN", VALUEFUNC(_wrap_Vector2_isNaN), -1);
  rb_define_method(SwigClassVector2.klass, "angleBetween", VALUEFUNC(_wrap_Vector2_angleBetween), -1);
  rb_define_method(SwigClassVector2.klass, "angleTo", VALUEFUNC(_wrap_Vector2_angleTo), -1);
  rb_define_singleton_method(SwigClassVector2.klass, "ZERO", VALUEFUNC(_wrap_Vector2_ZERO_get), 0);
  rb_define_singleton_method(SwigClassVector2.klass, "UNIT_X", VALUEFUNC(_wrap_Vector2_UNIT_X_get), 0);
  rb_define_singleton_method(SwigClassVector2.klass, "UNIT_Y", VALUEFUNC(_wrap_Vector2_UNIT_Y_get), 0);
  rb_define_singleton_method(SwigClassVector2.klass, "NEGATIVE_UNIT_X", VALUEFUNC(_wrap_Vector2_NEGATIVE_UNIT_X_get), 0);
  rb_define_singleton_method(SwigClassVector2.klass, "NEGATIVE_UNIT_Y", VALUEFUNC(_wrap_Vector2_NEGATIVE_UNIT_Y_get), 0);
  rb_define_singleton_method(SwigClassVector2.klass, "UNIT_SCALE", VALUEFUNC(_wrap_Vector2_UNIT_SCALE_get), 0);
  SwigClassVector2.mark = 0;
  SwigClassVector2.destroy = (void (*)(void *)) free_Ogre_Vector2;
  SwigClassVector2.trackObjects = 0;
  
  SwigClassQuaternion.klass = rb_define_class_under(mOgre, "Quaternion", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Quaternion, (void *) &SwigClassQuaternion);
  rb_define_alloc_func(SwigClassQuaternion.klass, _wrap_Quaternion_allocate);
  rb_define_method(SwigClassQuaternion.klass, "initialize", VALUEFUNC(_wrap_new_Quaternion), -1);
  rb_define_method(SwigClassQuaternion.klass, "swap", VALUEFUNC(_wrap_Quaternion_swap), -1);
  rb_define_method(SwigClassQuaternion.klass, "ptr", VALUEFUNC(_wrap_Quaternion_ptr), -1);
  rb_define_method(SwigClassQuaternion.klass, "FromRotationMatrix", VALUEFUNC(_wrap_Quaternion_FromRotationMatrix), -1);
  rb_define_method(SwigClassQuaternion.klass, "ToRotationMatrix", VALUEFUNC(_wrap_Quaternion_ToRotationMatrix), -1);
  rb_define_method(SwigClassQuaternion.klass, "FromAngleAxis", VALUEFUNC(_wrap_Quaternion_FromAngleAxis), -1);
  rb_define_method(SwigClassQuaternion.klass, "ToAngleAxis", VALUEFUNC(_wrap_Quaternion_ToAngleAxis), -1);
  rb_define_method(SwigClassQuaternion.klass, "FromAxes", VALUEFUNC(_wrap_Quaternion_FromAxes), -1);
  rb_define_method(SwigClassQuaternion.klass, "ToAxes", VALUEFUNC(_wrap_Quaternion_ToAxes), -1);
  rb_define_method(SwigClassQuaternion.klass, "xAxis", VALUEFUNC(_wrap_Quaternion_xAxis), -1);
  rb_define_method(SwigClassQuaternion.klass, "yAxis", VALUEFUNC(_wrap_Quaternion_yAxis), -1);
  rb_define_method(SwigClassQuaternion.klass, "zAxis", VALUEFUNC(_wrap_Quaternion_zAxis), -1);
  rb_define_method(SwigClassQuaternion.klass, "+", VALUEFUNC(_wrap_Quaternion___add__), -1);
  rb_define_method(SwigClassQuaternion.klass, "-", VALUEFUNC(_wrap_Quaternion___sub__), -1);
  rb_define_method(SwigClassQuaternion.klass, "-@", VALUEFUNC(_wrap_Quaternion___neg__), -1);
  rb_define_method(SwigClassQuaternion.klass, "==", VALUEFUNC(_wrap_Quaternion___eq__), -1);
  rb_define_method(SwigClassQuaternion.klass, "Dot", VALUEFUNC(_wrap_Quaternion_Dot), -1);
  rb_define_method(SwigClassQuaternion.klass, "Norm", VALUEFUNC(_wrap_Quaternion_Norm), -1);
  rb_define_method(SwigClassQuaternion.klass, "normalise", VALUEFUNC(_wrap_Quaternion_normalise), -1);
  rb_define_method(SwigClassQuaternion.klass, "Inverse", VALUEFUNC(_wrap_Quaternion_Inverse), -1);
  rb_define_method(SwigClassQuaternion.klass, "UnitInverse", VALUEFUNC(_wrap_Quaternion_UnitInverse), -1);
  rb_define_method(SwigClassQuaternion.klass, "Exp", VALUEFUNC(_wrap_Quaternion_Exp), -1);
  rb_define_method(SwigClassQuaternion.klass, "Log", VALUEFUNC(_wrap_Quaternion_Log), -1);
  rb_define_method(SwigClassQuaternion.klass, "*", VALUEFUNC(_wrap_Quaternion___mul__), -1);
  rb_define_method(SwigClassQuaternion.klass, "getRoll", VALUEFUNC(_wrap_Quaternion_getRoll), -1);
  rb_define_method(SwigClassQuaternion.klass, "getPitch", VALUEFUNC(_wrap_Quaternion_getPitch), -1);
  rb_define_method(SwigClassQuaternion.klass, "getYaw", VALUEFUNC(_wrap_Quaternion_getYaw), -1);
  rb_define_method(SwigClassQuaternion.klass, "equals", VALUEFUNC(_wrap_Quaternion_equals), -1);
  rb_define_singleton_method(SwigClassQuaternion.klass, "Slerp", VALUEFUNC(_wrap_Quaternion_Slerp), -1);
  rb_define_singleton_method(SwigClassQuaternion.klass, "SlerpExtraSpins", VALUEFUNC(_wrap_Quaternion_SlerpExtraSpins), -1);
  rb_define_singleton_method(SwigClassQuaternion.klass, "Intermediate", VALUEFUNC(_wrap_Quaternion_Intermediate), -1);
  rb_define_singleton_method(SwigClassQuaternion.klass, "Squad", VALUEFUNC(_wrap_Quaternion_Squad), -1);
  rb_define_singleton_method(SwigClassQuaternion.klass, "nlerp", VALUEFUNC(_wrap_Quaternion_nlerp), -1);
  rb_define_singleton_method(SwigClassQuaternion.klass, "msEpsilon", VALUEFUNC(_wrap_Quaternion_msEpsilon_get), 0);
  rb_define_singleton_method(SwigClassQuaternion.klass, "ZERO", VALUEFUNC(_wrap_Quaternion_ZERO_get), 0);
  rb_define_singleton_method(SwigClassQuaternion.klass, "IDENTITY", VALUEFUNC(_wrap_Quaternion_IDENTITY_get), 0);
  rb_define_method(SwigClassQuaternion.klass, "w=", VALUEFUNC(_wrap_Quaternion_w_set), -1);
  rb_define_method(SwigClassQuaternion.klass, "w", VALUEFUNC(_wrap_Quaternion_w_get), -1);
  rb_define_method(SwigClassQuaternion.klass, "x=", VALUEFUNC(_wrap_Quaternion_x_set), -1);
  rb_define_method(SwigClassQuaternion.klass, "x", VALUEFUNC(_wrap_Quaternion_x_get), -1);
  rb_define_method(SwigClassQuaternion.klass, "y=", VALUEFUNC(_wrap_Quaternion_y_set), -1);
  rb_define_method(SwigClassQuaternion.klass, "y", VALUEFUNC(_wrap_Quaternion_y_get), -1);
  rb_define_method(SwigClassQuaternion.klass, "z=", VALUEFUNC(_wrap_Quaternion_z_set), -1);
  rb_define_method(SwigClassQuaternion.klass, "z", VALUEFUNC(_wrap_Quaternion_z_get), -1);
  rb_define_method(SwigClassQuaternion.klass, "isNaN", VALUEFUNC(_wrap_Quaternion_isNaN), -1);
  SwigClassQuaternion.mark = 0;
  SwigClassQuaternion.destroy = (void (*)(void *)) free_Ogre_Quaternion;
  SwigClassQuaternion.trackObjects = 0;
  
  SwigClassVector3.klass = rb_define_class_under(mOgre, "Vector3", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Vector3, (void *) &SwigClassVector3);
  rb_define_alloc_func(SwigClassVector3.klass, _wrap_Vector3_allocate);
  rb_define_method(SwigClassVector3.klass, "initialize", VALUEFUNC(_wrap_new_Vector3), -1);
  rb_define_method(SwigClassVector3.klass, "x=", VALUEFUNC(_wrap_Vector3_x_set), -1);
  rb_define_method(SwigClassVector3.klass, "x", VALUEFUNC(_wrap_Vector3_x_get), -1);
  rb_define_method(SwigClassVector3.klass, "y=", VALUEFUNC(_wrap_Vector3_y_set), -1);
  rb_define_method(SwigClassVector3.klass, "y", VALUEFUNC(_wrap_Vector3_y_get), -1);
  rb_define_method(SwigClassVector3.klass, "z=", VALUEFUNC(_wrap_Vector3_z_set), -1);
  rb_define_method(SwigClassVector3.klass, "z", VALUEFUNC(_wrap_Vector3_z_get), -1);
  rb_define_method(SwigClassVector3.klass, "swap", VALUEFUNC(_wrap_Vector3_swap), -1);
  rb_define_method(SwigClassVector3.klass, "ptr", VALUEFUNC(_wrap_Vector3_ptr), -1);
  rb_define_method(SwigClassVector3.klass, "==", VALUEFUNC(_wrap_Vector3___eq__), -1);
  rb_define_method(SwigClassVector3.klass, "+", VALUEFUNC(_wrap_Vector3___add__), -1);
  rb_define_method(SwigClassVector3.klass, "-", VALUEFUNC(_wrap_Vector3___sub__), -1);
  rb_define_method(SwigClassVector3.klass, "*", VALUEFUNC(_wrap_Vector3___mul__), -1);
  rb_define_method(SwigClassVector3.klass, "/", VALUEFUNC(_wrap_Vector3___div__), -1);
  rb_define_method(SwigClassVector3.klass, "+@", VALUEFUNC(_wrap_Vector3___pos__), -1);
  rb_define_method(SwigClassVector3.klass, "-@", VALUEFUNC(_wrap_Vector3___neg__), -1);
  rb_define_method(SwigClassVector3.klass, "length", VALUEFUNC(_wrap_Vector3_length), -1);
  rb_define_method(SwigClassVector3.klass, "squaredLength", VALUEFUNC(_wrap_Vector3_squaredLength), -1);
  rb_define_method(SwigClassVector3.klass, "distance", VALUEFUNC(_wrap_Vector3_distance), -1);
  rb_define_method(SwigClassVector3.klass, "squaredDistance", VALUEFUNC(_wrap_Vector3_squaredDistance), -1);
  rb_define_method(SwigClassVector3.klass, "dotProduct", VALUEFUNC(_wrap_Vector3_dotProduct), -1);
  rb_define_method(SwigClassVector3.klass, "absDotProduct", VALUEFUNC(_wrap_Vector3_absDotProduct), -1);
  rb_define_method(SwigClassVector3.klass, "normalise", VALUEFUNC(_wrap_Vector3_normalise), -1);
  rb_define_method(SwigClassVector3.klass, "crossProduct", VALUEFUNC(_wrap_Vector3_crossProduct), -1);
  rb_define_method(SwigClassVector3.klass, "midPoint", VALUEFUNC(_wrap_Vector3_midPoint), -1);
  rb_define_method(SwigClassVector3.klass, "<", VALUEFUNC(_wrap_Vector3___lt__), -1);
  rb_define_method(SwigClassVector3.klass, ">", VALUEFUNC(_wrap_Vector3___gt__), -1);
  rb_define_method(SwigClassVector3.klass, "makeFloor", VALUEFUNC(_wrap_Vector3_makeFloor), -1);
  rb_define_method(SwigClassVector3.klass, "makeCeil", VALUEFUNC(_wrap_Vector3_makeCeil), -1);
  rb_define_method(SwigClassVector3.klass, "perpendicular", VALUEFUNC(_wrap_Vector3_perpendicular), -1);
  rb_define_method(SwigClassVector3.klass, "randomDeviant", VALUEFUNC(_wrap_Vector3_randomDeviant), -1);
  rb_define_method(SwigClassVector3.klass, "angleBetween", VALUEFUNC(_wrap_Vector3_angleBetween), -1);
  rb_define_method(SwigClassVector3.klass, "getRotationTo", VALUEFUNC(_wrap_Vector3_getRotationTo), -1);
  rb_define_method(SwigClassVector3.klass, "isZeroLength", VALUEFUNC(_wrap_Vector3_isZeroLength), -1);
  rb_define_method(SwigClassVector3.klass, "normalisedCopy", VALUEFUNC(_wrap_Vector3_normalisedCopy), -1);
  rb_define_method(SwigClassVector3.klass, "reflect", VALUEFUNC(_wrap_Vector3_reflect), -1);
  rb_define_method(SwigClassVector3.klass, "positionEquals", VALUEFUNC(_wrap_Vector3_positionEquals), -1);
  rb_define_method(SwigClassVector3.klass, "positionCloses", VALUEFUNC(_wrap_Vector3_positionCloses), -1);
  rb_define_method(SwigClassVector3.klass, "directionEquals", VALUEFUNC(_wrap_Vector3_directionEquals), -1);
  rb_define_method(SwigClassVector3.klass, "isNaN", VALUEFUNC(_wrap_Vector3_isNaN), -1);
  rb_define_method(SwigClassVector3.klass, "primaryAxis", VALUEFUNC(_wrap_Vector3_primaryAxis), -1);
  rb_define_singleton_method(SwigClassVector3.klass, "UNIT_X", VALUEFUNC(_wrap_Vector3_UNIT_X_get), 0);
  rb_define_singleton_method(SwigClassVector3.klass, "UNIT_Y", VALUEFUNC(_wrap_Vector3_UNIT_Y_get), 0);
  rb_define_singleton_method(SwigClassVector3.klass, "UNIT_Z", VALUEFUNC(_wrap_Vector3_UNIT_Z_get), 0);
  rb_define_singleton_method(SwigClassVector3.klass, "NEGATIVE_UNIT_X", VALUEFUNC(_wrap_Vector3_NEGATIVE_UNIT_X_get), 0);
  rb_define_singleton_method(SwigClassVector3.klass, "NEGATIVE_UNIT_Y", VALUEFUNC(_wrap_Vector3_NEGATIVE_UNIT_Y_get), 0);
  rb_define_singleton_method(SwigClassVector3.klass, "NEGATIVE_UNIT_Z", VALUEFUNC(_wrap_Vector3_NEGATIVE_UNIT_Z_get), 0);
  rb_define_singleton_method(SwigClassVector3.klass, "UNIT_SCALE", VALUEFUNC(_wrap_Vector3_UNIT_SCALE_get), 0);
  SwigClassVector3.mark = 0;
  SwigClassVector3.destroy = (void (*)(void *)) free_Ogre_Vector3;
  SwigClassVector3.trackObjects = 0;
  
  SwigClassVector4.klass = rb_define_class_under(mOgre, "Vector4", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Vector4, (void *) &SwigClassVector4);
  rb_define_alloc_func(SwigClassVector4.klass, _wrap_Vector4_allocate);
  rb_define_method(SwigClassVector4.klass, "initialize", VALUEFUNC(_wrap_new_Vector4), -1);
  rb_define_method(SwigClassVector4.klass, "x=", VALUEFUNC(_wrap_Vector4_x_set), -1);
  rb_define_method(SwigClassVector4.klass, "x", VALUEFUNC(_wrap_Vector4_x_get), -1);
  rb_define_method(SwigClassVector4.klass, "y=", VALUEFUNC(_wrap_Vector4_y_set), -1);
  rb_define_method(SwigClassVector4.klass, "y", VALUEFUNC(_wrap_Vector4_y_get), -1);
  rb_define_method(SwigClassVector4.klass, "z=", VALUEFUNC(_wrap_Vector4_z_set), -1);
  rb_define_method(SwigClassVector4.klass, "z", VALUEFUNC(_wrap_Vector4_z_get), -1);
  rb_define_method(SwigClassVector4.klass, "w=", VALUEFUNC(_wrap_Vector4_w_set), -1);
  rb_define_method(SwigClassVector4.klass, "w", VALUEFUNC(_wrap_Vector4_w_get), -1);
  rb_define_method(SwigClassVector4.klass, "swap", VALUEFUNC(_wrap_Vector4_swap), -1);
  rb_define_method(SwigClassVector4.klass, "ptr", VALUEFUNC(_wrap_Vector4_ptr), -1);
  rb_define_method(SwigClassVector4.klass, "==", VALUEFUNC(_wrap_Vector4___eq__), -1);
  rb_define_method(SwigClassVector4.klass, "+", VALUEFUNC(_wrap_Vector4___add__), -1);
  rb_define_method(SwigClassVector4.klass, "-", VALUEFUNC(_wrap_Vector4___sub__), -1);
  rb_define_method(SwigClassVector4.klass, "*", VALUEFUNC(_wrap_Vector4___mul__), -1);
  rb_define_method(SwigClassVector4.klass, "/", VALUEFUNC(_wrap_Vector4___div__), -1);
  rb_define_method(SwigClassVector4.klass, "+@", VALUEFUNC(_wrap_Vector4___pos__), -1);
  rb_define_method(SwigClassVector4.klass, "-@", VALUEFUNC(_wrap_Vector4___neg__), -1);
  rb_define_method(SwigClassVector4.klass, "dotProduct", VALUEFUNC(_wrap_Vector4_dotProduct), -1);
  rb_define_method(SwigClassVector4.klass, "isNaN", VALUEFUNC(_wrap_Vector4_isNaN), -1);
  rb_define_singleton_method(SwigClassVector4.klass, "ZERO", VALUEFUNC(_wrap_Vector4_ZERO_get), 0);
  SwigClassVector4.mark = 0;
  SwigClassVector4.destroy = (void (*)(void *)) free_Ogre_Vector4;
  SwigClassVector4.trackObjects = 0;
  
  SwigClassColourValue.klass = rb_define_class_under(mOgre, "ColourValue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ColourValue, (void *) &SwigClassColourValue);
  rb_define_alloc_func(SwigClassColourValue.klass, _wrap_ColourValue_allocate);
  rb_define_method(SwigClassColourValue.klass, "initialize", VALUEFUNC(_wrap_new_ColourValue), -1);
  rb_define_singleton_method(SwigClassColourValue.klass, "ZERO", VALUEFUNC(_wrap_ColourValue_ZERO_get), 0);
  rb_define_singleton_method(SwigClassColourValue.klass, "Black", VALUEFUNC(_wrap_ColourValue_Black_get), 0);
  rb_define_singleton_method(SwigClassColourValue.klass, "White", VALUEFUNC(_wrap_ColourValue_White_get), 0);
  rb_define_singleton_method(SwigClassColourValue.klass, "Red", VALUEFUNC(_wrap_ColourValue_Red_get), 0);
  rb_define_singleton_method(SwigClassColourValue.klass, "Green", VALUEFUNC(_wrap_ColourValue_Green_get), 0);
  rb_define_singleton_method(SwigClassColourValue.klass, "Blue", VALUEFUNC(_wrap_ColourValue_Blue_get), 0);
  rb_define_method(SwigClassColourValue.klass, "==", VALUEFUNC(_wrap_ColourValue___eq__), -1);
  rb_define_method(SwigClassColourValue.klass, "r=", VALUEFUNC(_wrap_ColourValue_r_set), -1);
  rb_define_method(SwigClassColourValue.klass, "r", VALUEFUNC(_wrap_ColourValue_r_get), -1);
  rb_define_method(SwigClassColourValue.klass, "g=", VALUEFUNC(_wrap_ColourValue_g_set), -1);
  rb_define_method(SwigClassColourValue.klass, "g", VALUEFUNC(_wrap_ColourValue_g_get), -1);
  rb_define_method(SwigClassColourValue.klass, "b=", VALUEFUNC(_wrap_ColourValue_b_set), -1);
  rb_define_method(SwigClassColourValue.klass, "b", VALUEFUNC(_wrap_ColourValue_b_get), -1);
  rb_define_method(SwigClassColourValue.klass, "a=", VALUEFUNC(_wrap_ColourValue_a_set), -1);
  rb_define_method(SwigClassColourValue.klass, "a", VALUEFUNC(_wrap_ColourValue_a_get), -1);
  rb_define_method(SwigClassColourValue.klass, "getAsRGBA", VALUEFUNC(_wrap_ColourValue_getAsRGBA), -1);
  rb_define_method(SwigClassColourValue.klass, "getAsARGB", VALUEFUNC(_wrap_ColourValue_getAsARGB), -1);
  rb_define_method(SwigClassColourValue.klass, "getAsBGRA", VALUEFUNC(_wrap_ColourValue_getAsBGRA), -1);
  rb_define_method(SwigClassColourValue.klass, "getAsABGR", VALUEFUNC(_wrap_ColourValue_getAsABGR), -1);
  rb_define_method(SwigClassColourValue.klass, "setAsRGBA", VALUEFUNC(_wrap_ColourValue_setAsRGBA), -1);
  rb_define_method(SwigClassColourValue.klass, "setAsARGB", VALUEFUNC(_wrap_ColourValue_setAsARGB), -1);
  rb_define_method(SwigClassColourValue.klass, "setAsBGRA", VALUEFUNC(_wrap_ColourValue_setAsBGRA), -1);
  rb_define_method(SwigClassColourValue.klass, "setAsABGR", VALUEFUNC(_wrap_ColourValue_setAsABGR), -1);
  rb_define_method(SwigClassColourValue.klass, "saturate", VALUEFUNC(_wrap_ColourValue_saturate), -1);
  rb_define_method(SwigClassColourValue.klass, "saturateCopy", VALUEFUNC(_wrap_ColourValue_saturateCopy), -1);
  rb_define_method(SwigClassColourValue.klass, "ptr", VALUEFUNC(_wrap_ColourValue_ptr), -1);
  rb_define_method(SwigClassColourValue.klass, "+", VALUEFUNC(_wrap_ColourValue___add__), -1);
  rb_define_method(SwigClassColourValue.klass, "-", VALUEFUNC(_wrap_ColourValue___sub__), -1);
  rb_define_method(SwigClassColourValue.klass, "*", VALUEFUNC(_wrap_ColourValue___mul__), -1);
  rb_define_method(SwigClassColourValue.klass, "/", VALUEFUNC(_wrap_ColourValue___div__), -1);
  rb_define_method(SwigClassColourValue.klass, "setHSB", VALUEFUNC(_wrap_ColourValue_setHSB), -1);
  rb_define_method(SwigClassColourValue.klass, "getHSB", VALUEFUNC(_wrap_ColourValue_getHSB), -1);
  SwigClassColourValue.mark = 0;
  SwigClassColourValue.destroy = (void (*)(void *)) free_Ogre_ColourValue;
  SwigClassColourValue.trackObjects = 0;
  rb_define_const(mOgre, "SPFM_DELETE", SWIG_From_int(static_cast< int >(Ogre::SPFM_DELETE)));
  rb_define_const(mOgre, "SPFM_DELETE_T", SWIG_From_int(static_cast< int >(Ogre::SPFM_DELETE_T)));
  rb_define_const(mOgre, "SPFM_FREE", SWIG_From_int(static_cast< int >(Ogre::SPFM_FREE)));
  
  SwigClassStringUtil.klass = rb_define_class_under(mOgre, "StringUtil", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__StringUtil, (void *) &SwigClassStringUtil);
  rb_define_alloc_func(SwigClassStringUtil.klass, _wrap_StringUtil_allocate);
  rb_define_method(SwigClassStringUtil.klass, "initialize", VALUEFUNC(_wrap_new_StringUtil), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "trim", VALUEFUNC(_wrap_StringUtil_trim), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "split", VALUEFUNC(_wrap_StringUtil_split), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "tokenise", VALUEFUNC(_wrap_StringUtil_tokenise), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "toLowerCase", VALUEFUNC(_wrap_StringUtil_toLowerCase), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "toUpperCase", VALUEFUNC(_wrap_StringUtil_toUpperCase), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "startsWith", VALUEFUNC(_wrap_StringUtil_startsWith), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "endsWith", VALUEFUNC(_wrap_StringUtil_endsWith), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "standardisePath", VALUEFUNC(_wrap_StringUtil_standardisePath), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "normalizeFilePath", VALUEFUNC(_wrap_StringUtil_normalizeFilePath), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "splitFilename", VALUEFUNC(_wrap_StringUtil_splitFilename), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "splitFullFilename", VALUEFUNC(_wrap_StringUtil_splitFullFilename), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "splitBaseFilename", VALUEFUNC(_wrap_StringUtil_splitBaseFilename), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "match", VALUEFUNC(_wrap_StringUtil_match), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "replaceAll", VALUEFUNC(_wrap_StringUtil_replaceAll), -1);
  rb_define_singleton_method(SwigClassStringUtil.klass, "BLANK", VALUEFUNC(_wrap_StringUtil_BLANK_get), 0);
  SwigClassStringUtil.mark = 0;
  SwigClassStringUtil.destroy = (void (*)(void *)) free_Ogre_StringUtil;
  SwigClassStringUtil.trackObjects = 0;
  
  SwigClassException.klass = rb_define_class_under(mOgre, "Exception", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Exception, (void *) &SwigClassException);
  rb_define_alloc_func(SwigClassException.klass, _wrap_Exception_allocate);
  rb_define_method(SwigClassException.klass, "initialize", VALUEFUNC(_wrap_new_Exception), -1);
  rb_define_const(SwigClassException.klass, "ERR_CANNOT_WRITE_TO_FILE", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_CANNOT_WRITE_TO_FILE)));
  rb_define_const(SwigClassException.klass, "ERR_INVALID_STATE", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_INVALID_STATE)));
  rb_define_const(SwigClassException.klass, "ERR_INVALIDPARAMS", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_INVALIDPARAMS)));
  rb_define_const(SwigClassException.klass, "ERR_RENDERINGAPI_ERROR", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_RENDERINGAPI_ERROR)));
  rb_define_const(SwigClassException.klass, "ERR_DUPLICATE_ITEM", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_DUPLICATE_ITEM)));
  rb_define_const(SwigClassException.klass, "ERR_ITEM_NOT_FOUND", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_ITEM_NOT_FOUND)));
  rb_define_const(SwigClassException.klass, "ERR_FILE_NOT_FOUND", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_FILE_NOT_FOUND)));
  rb_define_const(SwigClassException.klass, "ERR_INTERNAL_ERROR", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_INTERNAL_ERROR)));
  rb_define_const(SwigClassException.klass, "ERR_RT_ASSERTION_FAILED", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_RT_ASSERTION_FAILED)));
  rb_define_const(SwigClassException.klass, "ERR_NOT_IMPLEMENTED", SWIG_From_int(static_cast< int >(Ogre::Exception::ERR_NOT_IMPLEMENTED)));
  rb_define_method(SwigClassException.klass, "getFullDescription", VALUEFUNC(_wrap_Exception_getFullDescription), -1);
  rb_define_method(SwigClassException.klass, "getNumber", VALUEFUNC(_wrap_Exception_getNumber), -1);
  rb_define_method(SwigClassException.klass, "getSource", VALUEFUNC(_wrap_Exception_getSource), -1);
  rb_define_method(SwigClassException.klass, "getFile", VALUEFUNC(_wrap_Exception_getFile), -1);
  rb_define_method(SwigClassException.klass, "getLine", VALUEFUNC(_wrap_Exception_getLine), -1);
  rb_define_method(SwigClassException.klass, "getDescription", VALUEFUNC(_wrap_Exception_getDescription), -1);
  rb_define_method(SwigClassException.klass, "what", VALUEFUNC(_wrap_Exception_what), -1);
  SwigClassException.mark = 0;
  SwigClassException.destroy = (void (*)(void *)) free_Ogre_Exception;
  SwigClassException.trackObjects = 0;
  
  SwigClassUnimplementedException.klass = rb_define_class_under(mOgre, "UnimplementedException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__UnimplementedException, (void *) &SwigClassUnimplementedException);
  rb_define_alloc_func(SwigClassUnimplementedException.klass, _wrap_UnimplementedException_allocate);
  rb_define_method(SwigClassUnimplementedException.klass, "initialize", VALUEFUNC(_wrap_new_UnimplementedException), -1);
  SwigClassUnimplementedException.mark = 0;
  SwigClassUnimplementedException.destroy = (void (*)(void *)) free_Ogre_UnimplementedException;
  SwigClassUnimplementedException.trackObjects = 0;
  
  SwigClassFileNotFoundException.klass = rb_define_class_under(mOgre, "FileNotFoundException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FileNotFoundException, (void *) &SwigClassFileNotFoundException);
  rb_define_alloc_func(SwigClassFileNotFoundException.klass, _wrap_FileNotFoundException_allocate);
  rb_define_method(SwigClassFileNotFoundException.klass, "initialize", VALUEFUNC(_wrap_new_FileNotFoundException), -1);
  SwigClassFileNotFoundException.mark = 0;
  SwigClassFileNotFoundException.destroy = (void (*)(void *)) free_Ogre_FileNotFoundException;
  SwigClassFileNotFoundException.trackObjects = 0;
  
  SwigClassIOException.klass = rb_define_class_under(mOgre, "IOException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__IOException, (void *) &SwigClassIOException);
  rb_define_alloc_func(SwigClassIOException.klass, _wrap_IOException_allocate);
  rb_define_method(SwigClassIOException.klass, "initialize", VALUEFUNC(_wrap_new_IOException), -1);
  SwigClassIOException.mark = 0;
  SwigClassIOException.destroy = (void (*)(void *)) free_Ogre_IOException;
  SwigClassIOException.trackObjects = 0;
  
  SwigClassInvalidStateException.klass = rb_define_class_under(mOgre, "InvalidStateException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InvalidStateException, (void *) &SwigClassInvalidStateException);
  rb_define_alloc_func(SwigClassInvalidStateException.klass, _wrap_InvalidStateException_allocate);
  rb_define_method(SwigClassInvalidStateException.klass, "initialize", VALUEFUNC(_wrap_new_InvalidStateException), -1);
  SwigClassInvalidStateException.mark = 0;
  SwigClassInvalidStateException.destroy = (void (*)(void *)) free_Ogre_InvalidStateException;
  SwigClassInvalidStateException.trackObjects = 0;
  
  SwigClassInvalidParametersException.klass = rb_define_class_under(mOgre, "InvalidParametersException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InvalidParametersException, (void *) &SwigClassInvalidParametersException);
  rb_define_alloc_func(SwigClassInvalidParametersException.klass, _wrap_InvalidParametersException_allocate);
  rb_define_method(SwigClassInvalidParametersException.klass, "initialize", VALUEFUNC(_wrap_new_InvalidParametersException), -1);
  SwigClassInvalidParametersException.mark = 0;
  SwigClassInvalidParametersException.destroy = (void (*)(void *)) free_Ogre_InvalidParametersException;
  SwigClassInvalidParametersException.trackObjects = 0;
  
  SwigClassItemIdentityException.klass = rb_define_class_under(mOgre, "ItemIdentityException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ItemIdentityException, (void *) &SwigClassItemIdentityException);
  rb_define_alloc_func(SwigClassItemIdentityException.klass, _wrap_ItemIdentityException_allocate);
  rb_define_method(SwigClassItemIdentityException.klass, "initialize", VALUEFUNC(_wrap_new_ItemIdentityException), -1);
  SwigClassItemIdentityException.mark = 0;
  SwigClassItemIdentityException.destroy = (void (*)(void *)) free_Ogre_ItemIdentityException;
  SwigClassItemIdentityException.trackObjects = 0;
  
  SwigClassInternalErrorException.klass = rb_define_class_under(mOgre, "InternalErrorException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InternalErrorException, (void *) &SwigClassInternalErrorException);
  rb_define_alloc_func(SwigClassInternalErrorException.klass, _wrap_InternalErrorException_allocate);
  rb_define_method(SwigClassInternalErrorException.klass, "initialize", VALUEFUNC(_wrap_new_InternalErrorException), -1);
  SwigClassInternalErrorException.mark = 0;
  SwigClassInternalErrorException.destroy = (void (*)(void *)) free_Ogre_InternalErrorException;
  SwigClassInternalErrorException.trackObjects = 0;
  
  SwigClassRenderingAPIException.klass = rb_define_class_under(mOgre, "RenderingAPIException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderingAPIException, (void *) &SwigClassRenderingAPIException);
  rb_define_alloc_func(SwigClassRenderingAPIException.klass, _wrap_RenderingAPIException_allocate);
  rb_define_method(SwigClassRenderingAPIException.klass, "initialize", VALUEFUNC(_wrap_new_RenderingAPIException), -1);
  SwigClassRenderingAPIException.mark = 0;
  SwigClassRenderingAPIException.destroy = (void (*)(void *)) free_Ogre_RenderingAPIException;
  SwigClassRenderingAPIException.trackObjects = 0;
  
  SwigClassRuntimeAssertionException.klass = rb_define_class_under(mOgre, "RuntimeAssertionException", ((swig_class *) SWIGTYPE_p_Ogre__Exception->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RuntimeAssertionException, (void *) &SwigClassRuntimeAssertionException);
  rb_define_alloc_func(SwigClassRuntimeAssertionException.klass, _wrap_RuntimeAssertionException_allocate);
  rb_define_method(SwigClassRuntimeAssertionException.klass, "initialize", VALUEFUNC(_wrap_new_RuntimeAssertionException), -1);
  SwigClassRuntimeAssertionException.mark = 0;
  SwigClassRuntimeAssertionException.destroy = (void (*)(void *)) free_Ogre_RuntimeAssertionException;
  SwigClassRuntimeAssertionException.trackObjects = 0;
  
  SwigClassExceptionFactory.klass = rb_define_class_under(mOgre, "ExceptionFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ExceptionFactory, (void *) &SwigClassExceptionFactory);
  rb_undef_alloc_func(SwigClassExceptionFactory.klass);
  rb_define_singleton_method(SwigClassExceptionFactory.klass, "create", VALUEFUNC(_wrap_ExceptionFactory_create), -1);
  SwigClassExceptionFactory.mark = 0;
  SwigClassExceptionFactory.destroy = (void (*)(void *)) free_Ogre_ExceptionFactory;
  SwigClassExceptionFactory.trackObjects = 0;
  
  SwigClassAny.klass = rb_define_class_under(mOgre, "Any", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Any, (void *) &SwigClassAny);
  rb_define_alloc_func(SwigClassAny.klass, _wrap_Any_allocate);
  rb_define_method(SwigClassAny.klass, "initialize", VALUEFUNC(_wrap_new_Any), -1);
  rb_define_method(SwigClassAny.klass, "swap", VALUEFUNC(_wrap_Any_swap), -1);
  rb_define_method(SwigClassAny.klass, "isEmpty", VALUEFUNC(_wrap_Any_isEmpty), -1);
  rb_define_method(SwigClassAny.klass, "getType", VALUEFUNC(_wrap_Any_getType), -1);
  rb_define_method(SwigClassAny.klass, "destroy", VALUEFUNC(_wrap_Any_destroy), -1);
  rb_define_method(SwigClassAny.klass, "toVALUE", VALUEFUNC(_wrap_Any_toVALUE), -1);
  SwigClassAny.mark = 0;
  SwigClassAny.destroy = (void (*)(void *)) free_Ogre_Any;
  SwigClassAny.trackObjects = 0;
  
  SwigClassAnyNumeric.klass = rb_define_class_under(mOgre, "AnyNumeric", ((swig_class *) SWIGTYPE_p_Ogre__Any->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnyNumeric, (void *) &SwigClassAnyNumeric);
  rb_define_alloc_func(SwigClassAnyNumeric.klass, _wrap_AnyNumeric_allocate);
  rb_define_method(SwigClassAnyNumeric.klass, "initialize", VALUEFUNC(_wrap_new_AnyNumeric), -1);
  rb_define_method(SwigClassAnyNumeric.klass, "+", VALUEFUNC(_wrap_AnyNumeric___add__), -1);
  rb_define_method(SwigClassAnyNumeric.klass, "-", VALUEFUNC(_wrap_AnyNumeric___sub__), -1);
  rb_define_method(SwigClassAnyNumeric.klass, "*", VALUEFUNC(_wrap_AnyNumeric___mul__), -1);
  rb_define_method(SwigClassAnyNumeric.klass, "/", VALUEFUNC(_wrap_AnyNumeric___div__), -1);
  SwigClassAnyNumeric.mark = 0;
  SwigClassAnyNumeric.destroy = (void (*)(void *)) free_Ogre_AnyNumeric;
  SwigClassAnyNumeric.trackObjects = 0;
  
  SwigClassAnyVALUE.klass = rb_define_class_under(mOgre, "AnyVALUE", ((swig_class *) SWIGTYPE_p_Ogre__Any->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnyVALUE, (void *) &SwigClassAnyVALUE);
  rb_define_alloc_func(SwigClassAnyVALUE.klass, _wrap_AnyVALUE_allocate);
  rb_define_method(SwigClassAnyVALUE.klass, "initialize", VALUEFUNC(_wrap_new_AnyVALUE), -1);
  rb_define_method(SwigClassAnyVALUE.klass, "setVALUE", VALUEFUNC(_wrap_AnyVALUE_setVALUE), -1);
  rb_define_method(SwigClassAnyVALUE.klass, "getVALUE", VALUEFUNC(_wrap_AnyVALUE_getVALUE), -1);
  SwigClassAnyVALUE.mark = 0;
  SwigClassAnyVALUE.destroy = (void (*)(void *)) free_Ogre_AnyVALUE;
  SwigClassAnyVALUE.trackObjects = 0;
  
  SwigClassAnimableValue.klass = rb_define_class_under(mOgre, "AnimableValue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimableValue, (void *) &SwigClassAnimableValue);
  rb_undef_alloc_func(SwigClassAnimableValue.klass);
  rb_define_const(SwigClassAnimableValue.klass, "INT", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::INT)));
  rb_define_const(SwigClassAnimableValue.klass, "REAL", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::REAL)));
  rb_define_const(SwigClassAnimableValue.klass, "VECTOR2", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::VECTOR2)));
  rb_define_const(SwigClassAnimableValue.klass, "VECTOR3", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::VECTOR3)));
  rb_define_const(SwigClassAnimableValue.klass, "VECTOR4", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::VECTOR4)));
  rb_define_const(SwigClassAnimableValue.klass, "QUATERNION", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::QUATERNION)));
  rb_define_const(SwigClassAnimableValue.klass, "COLOUR", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::COLOUR)));
  rb_define_const(SwigClassAnimableValue.klass, "RADIAN", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::RADIAN)));
  rb_define_const(SwigClassAnimableValue.klass, "DEGREE", SWIG_From_int(static_cast< int >(Ogre::AnimableValue::DEGREE)));
  rb_define_method(SwigClassAnimableValue.klass, "getType", VALUEFUNC(_wrap_AnimableValue_getType), -1);
  rb_define_method(SwigClassAnimableValue.klass, "setCurrentStateAsBaseValue", VALUEFUNC(_wrap_AnimableValue_setCurrentStateAsBaseValue), -1);
  rb_define_method(SwigClassAnimableValue.klass, "setValue", VALUEFUNC(_wrap_AnimableValue_setValue), -1);
  rb_define_method(SwigClassAnimableValue.klass, "resetToBaseValue", VALUEFUNC(_wrap_AnimableValue_resetToBaseValue), -1);
  rb_define_method(SwigClassAnimableValue.klass, "applyDeltaValue", VALUEFUNC(_wrap_AnimableValue_applyDeltaValue), -1);
  SwigClassAnimableValue.mark = 0;
  SwigClassAnimableValue.destroy = (void (*)(void *)) free_Ogre_AnimableValue;
  SwigClassAnimableValue.trackObjects = 0;
  
  SwigClassAnimableObject.klass = rb_define_class_under(mOgre, "AnimableObject", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimableObject, (void *) &SwigClassAnimableObject);
  rb_define_alloc_func(SwigClassAnimableObject.klass, _wrap_AnimableObject_allocate);
  rb_define_method(SwigClassAnimableObject.klass, "initialize", VALUEFUNC(_wrap_new_AnimableObject), -1);
  rb_define_method(SwigClassAnimableObject.klass, "getAnimableValueNames", VALUEFUNC(_wrap_AnimableObject_getAnimableValueNames), -1);
  rb_define_method(SwigClassAnimableObject.klass, "createAnimableValue", VALUEFUNC(_wrap_AnimableObject_createAnimableValue), -1);
  SwigClassAnimableObject.mark = 0;
  SwigClassAnimableObject.destroy = (void (*)(void *)) free_Ogre_AnimableObject;
  SwigClassAnimableObject.trackObjects = 0;
  
  SwigClassMatrix3.klass = rb_define_class_under(mOgre, "Matrix3", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Matrix3, (void *) &SwigClassMatrix3);
  rb_define_alloc_func(SwigClassMatrix3.klass, _wrap_Matrix3_allocate);
  rb_define_method(SwigClassMatrix3.klass, "initialize", VALUEFUNC(_wrap_new_Matrix3), -1);
  rb_define_method(SwigClassMatrix3.klass, "swap", VALUEFUNC(_wrap_Matrix3_swap), -1);
  rb_define_method(SwigClassMatrix3.klass, "GetColumn", VALUEFUNC(_wrap_Matrix3_GetColumn), -1);
  rb_define_method(SwigClassMatrix3.klass, "SetColumn", VALUEFUNC(_wrap_Matrix3_SetColumn), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromAxes", VALUEFUNC(_wrap_Matrix3_FromAxes), -1);
  rb_define_method(SwigClassMatrix3.klass, "==", VALUEFUNC(_wrap_Matrix3___eq__), -1);
  rb_define_method(SwigClassMatrix3.klass, "+", VALUEFUNC(_wrap_Matrix3___add__), -1);
  rb_define_method(SwigClassMatrix3.klass, "-", VALUEFUNC(_wrap_Matrix3___sub__), -1);
  rb_define_method(SwigClassMatrix3.klass, "-@", VALUEFUNC(_wrap_Matrix3___neg__), -1);
  rb_define_method(SwigClassMatrix3.klass, "*", VALUEFUNC(_wrap_Matrix3___mul__), -1);
  rb_define_method(SwigClassMatrix3.klass, "Transpose", VALUEFUNC(_wrap_Matrix3_Transpose), -1);
  rb_define_method(SwigClassMatrix3.klass, "Inverse", VALUEFUNC(_wrap_Matrix3_Inverse), -1);
  rb_define_method(SwigClassMatrix3.klass, "Determinant", VALUEFUNC(_wrap_Matrix3_Determinant), -1);
  rb_define_method(SwigClassMatrix3.klass, "SingularValueDecomposition", VALUEFUNC(_wrap_Matrix3_SingularValueDecomposition), -1);
  rb_define_method(SwigClassMatrix3.klass, "SingularValueComposition", VALUEFUNC(_wrap_Matrix3_SingularValueComposition), -1);
  rb_define_method(SwigClassMatrix3.klass, "Orthonormalize", VALUEFUNC(_wrap_Matrix3_Orthonormalize), -1);
  rb_define_method(SwigClassMatrix3.klass, "QDUDecomposition", VALUEFUNC(_wrap_Matrix3_QDUDecomposition), -1);
  rb_define_method(SwigClassMatrix3.klass, "SpectralNorm", VALUEFUNC(_wrap_Matrix3_SpectralNorm), -1);
  rb_define_method(SwigClassMatrix3.klass, "ToAngleAxis", VALUEFUNC(_wrap_Matrix3_ToAngleAxis), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromAngleAxis", VALUEFUNC(_wrap_Matrix3_FromAngleAxis), -1);
  rb_define_method(SwigClassMatrix3.klass, "ToEulerAnglesXYZ", VALUEFUNC(_wrap_Matrix3_ToEulerAnglesXYZ), -1);
  rb_define_method(SwigClassMatrix3.klass, "ToEulerAnglesXZY", VALUEFUNC(_wrap_Matrix3_ToEulerAnglesXZY), -1);
  rb_define_method(SwigClassMatrix3.klass, "ToEulerAnglesYXZ", VALUEFUNC(_wrap_Matrix3_ToEulerAnglesYXZ), -1);
  rb_define_method(SwigClassMatrix3.klass, "ToEulerAnglesYZX", VALUEFUNC(_wrap_Matrix3_ToEulerAnglesYZX), -1);
  rb_define_method(SwigClassMatrix3.klass, "ToEulerAnglesZXY", VALUEFUNC(_wrap_Matrix3_ToEulerAnglesZXY), -1);
  rb_define_method(SwigClassMatrix3.klass, "ToEulerAnglesZYX", VALUEFUNC(_wrap_Matrix3_ToEulerAnglesZYX), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromEulerAnglesXYZ", VALUEFUNC(_wrap_Matrix3_FromEulerAnglesXYZ), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromEulerAnglesXZY", VALUEFUNC(_wrap_Matrix3_FromEulerAnglesXZY), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromEulerAnglesYXZ", VALUEFUNC(_wrap_Matrix3_FromEulerAnglesYXZ), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromEulerAnglesYZX", VALUEFUNC(_wrap_Matrix3_FromEulerAnglesYZX), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromEulerAnglesZXY", VALUEFUNC(_wrap_Matrix3_FromEulerAnglesZXY), -1);
  rb_define_method(SwigClassMatrix3.klass, "FromEulerAnglesZYX", VALUEFUNC(_wrap_Matrix3_FromEulerAnglesZYX), -1);
  rb_define_method(SwigClassMatrix3.klass, "EigenSolveSymmetric", VALUEFUNC(_wrap_Matrix3_EigenSolveSymmetric), -1);
  rb_define_singleton_method(SwigClassMatrix3.klass, "TensorProduct", VALUEFUNC(_wrap_Matrix3_TensorProduct), -1);
  rb_define_method(SwigClassMatrix3.klass, "hasScale", VALUEFUNC(_wrap_Matrix3_hasScale), -1);
  rb_define_singleton_method(SwigClassMatrix3.klass, "EPSILON", VALUEFUNC(_wrap_Matrix3_EPSILON_get), 0);
  rb_define_singleton_method(SwigClassMatrix3.klass, "ZERO", VALUEFUNC(_wrap_Matrix3_ZERO_get), 0);
  rb_define_singleton_method(SwigClassMatrix3.klass, "IDENTITY", VALUEFUNC(_wrap_Matrix3_IDENTITY_get), 0);
  SwigClassMatrix3.mark = 0;
  SwigClassMatrix3.destroy = (void (*)(void *)) free_Ogre_Matrix3;
  SwigClassMatrix3.trackObjects = 0;
  
  SwigClassPlane.klass = rb_define_class_under(mOgre, "Plane", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Plane, (void *) &SwigClassPlane);
  rb_define_alloc_func(SwigClassPlane.klass, _wrap_Plane_allocate);
  rb_define_method(SwigClassPlane.klass, "initialize", VALUEFUNC(_wrap_new_Plane), -1);
  rb_define_const(SwigClassPlane.klass, "NO_SIDE", SWIG_From_int(static_cast< int >(Ogre::Plane::NO_SIDE)));
  rb_define_const(SwigClassPlane.klass, "POSITIVE_SIDE", SWIG_From_int(static_cast< int >(Ogre::Plane::POSITIVE_SIDE)));
  rb_define_const(SwigClassPlane.klass, "NEGATIVE_SIDE", SWIG_From_int(static_cast< int >(Ogre::Plane::NEGATIVE_SIDE)));
  rb_define_const(SwigClassPlane.klass, "BOTH_SIDE", SWIG_From_int(static_cast< int >(Ogre::Plane::BOTH_SIDE)));
  rb_define_method(SwigClassPlane.klass, "getSide", VALUEFUNC(_wrap_Plane_getSide), -1);
  rb_define_method(SwigClassPlane.klass, "getDistance", VALUEFUNC(_wrap_Plane_getDistance), -1);
  rb_define_method(SwigClassPlane.klass, "redefine", VALUEFUNC(_wrap_Plane_redefine), -1);
  rb_define_method(SwigClassPlane.klass, "projectVector", VALUEFUNC(_wrap_Plane_projectVector), -1);
  rb_define_method(SwigClassPlane.klass, "normalise", VALUEFUNC(_wrap_Plane_normalise), -1);
  rb_define_method(SwigClassPlane.klass, "normal=", VALUEFUNC(_wrap_Plane_normal_set), -1);
  rb_define_method(SwigClassPlane.klass, "normal", VALUEFUNC(_wrap_Plane_normal_get), -1);
  rb_define_method(SwigClassPlane.klass, "d=", VALUEFUNC(_wrap_Plane_d_set), -1);
  rb_define_method(SwigClassPlane.klass, "d", VALUEFUNC(_wrap_Plane_d_get), -1);
  rb_define_method(SwigClassPlane.klass, "==", VALUEFUNC(_wrap_Plane___eq__), -1);
  SwigClassPlane.mark = 0;
  SwigClassPlane.destroy = (void (*)(void *)) free_Ogre_Plane;
  SwigClassPlane.trackObjects = 0;
  
  SwigClassMatrix4.klass = rb_define_class_under(mOgre, "Matrix4", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Matrix4, (void *) &SwigClassMatrix4);
  rb_define_alloc_func(SwigClassMatrix4.klass, _wrap_Matrix4_allocate);
  rb_define_method(SwigClassMatrix4.klass, "initialize", VALUEFUNC(_wrap_new_Matrix4), -1);
  rb_define_method(SwigClassMatrix4.klass, "swap", VALUEFUNC(_wrap_Matrix4_swap), -1);
  rb_define_method(SwigClassMatrix4.klass, "concatenate", VALUEFUNC(_wrap_Matrix4_concatenate), -1);
  rb_define_method(SwigClassMatrix4.klass, "+", VALUEFUNC(_wrap_Matrix4___add__), -1);
  rb_define_method(SwigClassMatrix4.klass, "-", VALUEFUNC(_wrap_Matrix4___sub__), -1);
  rb_define_method(SwigClassMatrix4.klass, "==", VALUEFUNC(_wrap_Matrix4___eq__), -1);
  rb_define_method(SwigClassMatrix4.klass, "transpose", VALUEFUNC(_wrap_Matrix4_transpose), -1);
  rb_define_method(SwigClassMatrix4.klass, "setTrans", VALUEFUNC(_wrap_Matrix4_setTrans), -1);
  rb_define_method(SwigClassMatrix4.klass, "makeTrans", VALUEFUNC(_wrap_Matrix4_makeTrans), -1);
  rb_define_singleton_method(SwigClassMatrix4.klass, "getTrans", VALUEFUNC(_wrap_Matrix4_getTrans), -1);
  rb_define_method(SwigClassMatrix4.klass, "setScale", VALUEFUNC(_wrap_Matrix4_setScale), -1);
  rb_define_singleton_method(SwigClassMatrix4.klass, "getScale", VALUEFUNC(_wrap_Matrix4_getScale), -1);
  rb_define_method(SwigClassMatrix4.klass, "extract3x3Matrix", VALUEFUNC(_wrap_Matrix4_extract3x3Matrix), -1);
  rb_define_method(SwigClassMatrix4.klass, "hasScale", VALUEFUNC(_wrap_Matrix4_hasScale), -1);
  rb_define_method(SwigClassMatrix4.klass, "hasNegativeScale", VALUEFUNC(_wrap_Matrix4_hasNegativeScale), -1);
  rb_define_method(SwigClassMatrix4.klass, "extractQuaternion", VALUEFUNC(_wrap_Matrix4_extractQuaternion), -1);
  rb_define_singleton_method(SwigClassMatrix4.klass, "ZERO", VALUEFUNC(_wrap_Matrix4_ZERO_get), 0);
  rb_define_singleton_method(SwigClassMatrix4.klass, "ZEROAFFINE", VALUEFUNC(_wrap_Matrix4_ZEROAFFINE_get), 0);
  rb_define_singleton_method(SwigClassMatrix4.klass, "IDENTITY", VALUEFUNC(_wrap_Matrix4_IDENTITY_get), 0);
  rb_define_singleton_method(SwigClassMatrix4.klass, "CLIPSPACE2DTOIMAGESPACE", VALUEFUNC(_wrap_Matrix4_CLIPSPACE2DTOIMAGESPACE_get), 0);
  rb_define_method(SwigClassMatrix4.klass, "*", VALUEFUNC(_wrap_Matrix4___mul__), -1);
  rb_define_method(SwigClassMatrix4.klass, "adjoint", VALUEFUNC(_wrap_Matrix4_adjoint), -1);
  rb_define_method(SwigClassMatrix4.klass, "determinant", VALUEFUNC(_wrap_Matrix4_determinant), -1);
  rb_define_method(SwigClassMatrix4.klass, "inverse", VALUEFUNC(_wrap_Matrix4_inverse), -1);
  rb_define_method(SwigClassMatrix4.klass, "makeTransform", VALUEFUNC(_wrap_Matrix4_makeTransform), -1);
  rb_define_method(SwigClassMatrix4.klass, "makeInverseTransform", VALUEFUNC(_wrap_Matrix4_makeInverseTransform), -1);
  rb_define_method(SwigClassMatrix4.klass, "decomposition", VALUEFUNC(_wrap_Matrix4_decomposition), -1);
  rb_define_method(SwigClassMatrix4.klass, "isAffine", VALUEFUNC(_wrap_Matrix4_isAffine), -1);
  rb_define_method(SwigClassMatrix4.klass, "inverseAffine", VALUEFUNC(_wrap_Matrix4_inverseAffine), -1);
  rb_define_method(SwigClassMatrix4.klass, "concatenateAffine", VALUEFUNC(_wrap_Matrix4_concatenateAffine), -1);
  rb_define_method(SwigClassMatrix4.klass, "transformAffine", VALUEFUNC(_wrap_Matrix4_transformAffine), -1);
  SwigClassMatrix4.mark = 0;
  SwigClassMatrix4.destroy = (void (*)(void *)) free_Ogre_Matrix4;
  SwigClassMatrix4.trackObjects = 0;
  rb_define_module_function(mOgre, "*", VALUEFUNC(_wrap___mul__), -1);
  
  SwigClassSimpleSpline.klass = rb_define_class_under(mOgre, "SimpleSpline", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SimpleSpline, (void *) &SwigClassSimpleSpline);
  rb_define_alloc_func(SwigClassSimpleSpline.klass, _wrap_SimpleSpline_allocate);
  rb_define_method(SwigClassSimpleSpline.klass, "initialize", VALUEFUNC(_wrap_new_SimpleSpline), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "addPoint", VALUEFUNC(_wrap_SimpleSpline_addPoint), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "getPoint", VALUEFUNC(_wrap_SimpleSpline_getPoint), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "getNumPoints", VALUEFUNC(_wrap_SimpleSpline_getNumPoints), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "clear", VALUEFUNC(_wrap_SimpleSpline_clear), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "updatePoint", VALUEFUNC(_wrap_SimpleSpline_updatePoint), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "interpolate", VALUEFUNC(_wrap_SimpleSpline_interpolate), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "setAutoCalculate", VALUEFUNC(_wrap_SimpleSpline_setAutoCalculate), -1);
  rb_define_method(SwigClassSimpleSpline.klass, "recalcTangents", VALUEFUNC(_wrap_SimpleSpline_recalcTangents), -1);
  SwigClassSimpleSpline.mark = 0;
  SwigClassSimpleSpline.destroy = (void (*)(void *)) free_Ogre_SimpleSpline;
  SwigClassSimpleSpline.trackObjects = 0;
  
  SwigClassRotationalSpline.klass = rb_define_class_under(mOgre, "RotationalSpline", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RotationalSpline, (void *) &SwigClassRotationalSpline);
  rb_define_alloc_func(SwigClassRotationalSpline.klass, _wrap_RotationalSpline_allocate);
  rb_define_method(SwigClassRotationalSpline.klass, "initialize", VALUEFUNC(_wrap_new_RotationalSpline), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "addPoint", VALUEFUNC(_wrap_RotationalSpline_addPoint), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "getPoint", VALUEFUNC(_wrap_RotationalSpline_getPoint), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "getNumPoints", VALUEFUNC(_wrap_RotationalSpline_getNumPoints), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "clear", VALUEFUNC(_wrap_RotationalSpline_clear), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "updatePoint", VALUEFUNC(_wrap_RotationalSpline_updatePoint), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "interpolate", VALUEFUNC(_wrap_RotationalSpline_interpolate), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "setAutoCalculate", VALUEFUNC(_wrap_RotationalSpline_setAutoCalculate), -1);
  rb_define_method(SwigClassRotationalSpline.klass, "recalcTangents", VALUEFUNC(_wrap_RotationalSpline_recalcTangents), -1);
  SwigClassRotationalSpline.mark = 0;
  SwigClassRotationalSpline.destroy = (void (*)(void *)) free_Ogre_RotationalSpline;
  SwigClassRotationalSpline.trackObjects = 0;
  
  SwigClassHardwareBuffer.klass = rb_define_class_under(mOgre, "HardwareBuffer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareBuffer, (void *) &SwigClassHardwareBuffer);
  rb_undef_alloc_func(SwigClassHardwareBuffer.klass);
  rb_define_const(SwigClassHardwareBuffer.klass, "HBU_STATIC", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBU_STATIC)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBU_DYNAMIC", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBU_DYNAMIC)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBU_WRITE_ONLY", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBU_WRITE_ONLY)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBU_DISCARDABLE", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBU_DISCARDABLE)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBU_STATIC_WRITE_ONLY", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBU_STATIC_WRITE_ONLY)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBU_DYNAMIC_WRITE_ONLY", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY_DISCARDABLE)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBL_NORMAL", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBL_NORMAL)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBL_DISCARD", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBL_DISCARD)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBL_READ_ONLY", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBL_READ_ONLY)));
  rb_define_const(SwigClassHardwareBuffer.klass, "HBL_NO_OVERWRITE", SWIG_From_int(static_cast< int >(Ogre::HardwareBuffer::HBL_NO_OVERWRITE)));
  rb_define_method(SwigClassHardwareBuffer.klass, "lock", VALUEFUNC(_wrap_HardwareBuffer_lock), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "unlock", VALUEFUNC(_wrap_HardwareBuffer_unlock), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "readData", VALUEFUNC(_wrap_HardwareBuffer_readData), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "writeData", VALUEFUNC(_wrap_HardwareBuffer_writeData), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "copyData", VALUEFUNC(_wrap_HardwareBuffer_copyData), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "_updateFromShadow", VALUEFUNC(_wrap_HardwareBuffer__updateFromShadow), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "getSizeInBytes", VALUEFUNC(_wrap_HardwareBuffer_getSizeInBytes), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "getUsage", VALUEFUNC(_wrap_HardwareBuffer_getUsage), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "isSystemMemory", VALUEFUNC(_wrap_HardwareBuffer_isSystemMemory), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "hasShadowBuffer", VALUEFUNC(_wrap_HardwareBuffer_hasShadowBuffer), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "isLocked", VALUEFUNC(_wrap_HardwareBuffer_isLocked), -1);
  rb_define_method(SwigClassHardwareBuffer.klass, "suppressHardwareUpdate", VALUEFUNC(_wrap_HardwareBuffer_suppressHardwareUpdate), -1);
  SwigClassHardwareBuffer.mark = 0;
  SwigClassHardwareBuffer.destroy = (void (*)(void *)) free_Ogre_HardwareBuffer;
  SwigClassHardwareBuffer.trackObjects = 0;
  
  SwigClassHardwareVertexBuffer.klass = rb_define_class_under(mOgre, "HardwareVertexBuffer", ((swig_class *) SWIGTYPE_p_Ogre__HardwareBuffer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareVertexBuffer, (void *) &SwigClassHardwareVertexBuffer);
  rb_undef_alloc_func(SwigClassHardwareVertexBuffer.klass);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "getManager", VALUEFUNC(_wrap_HardwareVertexBuffer_getManager), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "getVertexSize", VALUEFUNC(_wrap_HardwareVertexBuffer_getVertexSize), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "getNumVertices", VALUEFUNC(_wrap_HardwareVertexBuffer_getNumVertices), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "getIsInstanceData", VALUEFUNC(_wrap_HardwareVertexBuffer_getIsInstanceData), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "setIsInstanceData", VALUEFUNC(_wrap_HardwareVertexBuffer_setIsInstanceData), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "getInstanceDataStepRate", VALUEFUNC(_wrap_HardwareVertexBuffer_getInstanceDataStepRate), -1);
  rb_define_method(SwigClassHardwareVertexBuffer.klass, "setInstanceDataStepRate", VALUEFUNC(_wrap_HardwareVertexBuffer_setInstanceDataStepRate), -1);
  SwigClassHardwareVertexBuffer.mark = 0;
  SwigClassHardwareVertexBuffer.destroy = (void (*)(void *)) free_Ogre_HardwareVertexBuffer;
  SwigClassHardwareVertexBuffer.trackObjects = 0;
  
  SwigClassHardwareVertexBufferSharedPtr.klass = rb_define_class_under(mOgre, "HardwareVertexBufferSharedPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareVertexBufferSharedPtr, (void *) &SwigClassHardwareVertexBufferSharedPtr);
  rb_define_alloc_func(SwigClassHardwareVertexBufferSharedPtr.klass, _wrap_HardwareVertexBufferSharedPtr_allocate);
  rb_define_method(SwigClassHardwareVertexBufferSharedPtr.klass, "initialize", VALUEFUNC(_wrap_new_HardwareVertexBufferSharedPtr), -1);
  SwigClassHardwareVertexBufferSharedPtr.mark = 0;
  SwigClassHardwareVertexBufferSharedPtr.destroy = (void (*)(void *)) free_Ogre_HardwareVertexBufferSharedPtr;
  SwigClassHardwareVertexBufferSharedPtr.trackObjects = 0;
  rb_define_const(mOgre, "VES_POSITION", SWIG_From_int(static_cast< int >(Ogre::VES_POSITION)));
  rb_define_const(mOgre, "VES_BLEND_WEIGHTS", SWIG_From_int(static_cast< int >(Ogre::VES_BLEND_WEIGHTS)));
  rb_define_const(mOgre, "VES_BLEND_INDICES", SWIG_From_int(static_cast< int >(Ogre::VES_BLEND_INDICES)));
  rb_define_const(mOgre, "VES_NORMAL", SWIG_From_int(static_cast< int >(Ogre::VES_NORMAL)));
  rb_define_const(mOgre, "VES_DIFFUSE", SWIG_From_int(static_cast< int >(Ogre::VES_DIFFUSE)));
  rb_define_const(mOgre, "VES_SPECULAR", SWIG_From_int(static_cast< int >(Ogre::VES_SPECULAR)));
  rb_define_const(mOgre, "VES_TEXTURE_COORDINATES", SWIG_From_int(static_cast< int >(Ogre::VES_TEXTURE_COORDINATES)));
  rb_define_const(mOgre, "VES_BINORMAL", SWIG_From_int(static_cast< int >(Ogre::VES_BINORMAL)));
  rb_define_const(mOgre, "VES_TANGENT", SWIG_From_int(static_cast< int >(Ogre::VES_TANGENT)));
  rb_define_const(mOgre, "VES_COUNT", SWIG_From_int(static_cast< int >(Ogre::VES_COUNT)));
  rb_define_const(mOgre, "VET_FLOAT1", SWIG_From_int(static_cast< int >(Ogre::VET_FLOAT1)));
  rb_define_const(mOgre, "VET_FLOAT2", SWIG_From_int(static_cast< int >(Ogre::VET_FLOAT2)));
  rb_define_const(mOgre, "VET_FLOAT3", SWIG_From_int(static_cast< int >(Ogre::VET_FLOAT3)));
  rb_define_const(mOgre, "VET_FLOAT4", SWIG_From_int(static_cast< int >(Ogre::VET_FLOAT4)));
  rb_define_const(mOgre, "VET_COLOUR", SWIG_From_int(static_cast< int >(Ogre::VET_COLOUR)));
  rb_define_const(mOgre, "VET_SHORT1", SWIG_From_int(static_cast< int >(Ogre::VET_SHORT1)));
  rb_define_const(mOgre, "VET_SHORT2", SWIG_From_int(static_cast< int >(Ogre::VET_SHORT2)));
  rb_define_const(mOgre, "VET_SHORT3", SWIG_From_int(static_cast< int >(Ogre::VET_SHORT3)));
  rb_define_const(mOgre, "VET_SHORT4", SWIG_From_int(static_cast< int >(Ogre::VET_SHORT4)));
  rb_define_const(mOgre, "VET_UBYTE4", SWIG_From_int(static_cast< int >(Ogre::VET_UBYTE4)));
  rb_define_const(mOgre, "VET_COLOUR_ARGB", SWIG_From_int(static_cast< int >(Ogre::VET_COLOUR_ARGB)));
  rb_define_const(mOgre, "VET_COLOUR_ABGR", SWIG_From_int(static_cast< int >(Ogre::VET_COLOUR_ABGR)));
  
  SwigClassVertexElement.klass = rb_define_class_under(mOgre, "VertexElement", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexElement, (void *) &SwigClassVertexElement);
  rb_define_alloc_func(SwigClassVertexElement.klass, _wrap_VertexElement_allocate);
  rb_define_method(SwigClassVertexElement.klass, "initialize", VALUEFUNC(_wrap_new_VertexElement), -1);
  rb_define_method(SwigClassVertexElement.klass, "getSource", VALUEFUNC(_wrap_VertexElement_getSource), -1);
  rb_define_method(SwigClassVertexElement.klass, "getOffset", VALUEFUNC(_wrap_VertexElement_getOffset), -1);
  rb_define_method(SwigClassVertexElement.klass, "getType", VALUEFUNC(_wrap_VertexElement_getType), -1);
  rb_define_method(SwigClassVertexElement.klass, "getSemantic", VALUEFUNC(_wrap_VertexElement_getSemantic), -1);
  rb_define_method(SwigClassVertexElement.klass, "getIndex", VALUEFUNC(_wrap_VertexElement_getIndex), -1);
  rb_define_method(SwigClassVertexElement.klass, "getSize", VALUEFUNC(_wrap_VertexElement_getSize), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "getTypeSize", VALUEFUNC(_wrap_VertexElement_getTypeSize), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "getTypeCount", VALUEFUNC(_wrap_VertexElement_getTypeCount), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "multiplyTypeCount", VALUEFUNC(_wrap_VertexElement_multiplyTypeCount), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "getBaseType", VALUEFUNC(_wrap_VertexElement_getBaseType), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "convertColourValue", VALUEFUNC(_wrap_VertexElement_convertColourValue), -1);
  rb_define_singleton_method(SwigClassVertexElement.klass, "getBestColourVertexElementType", VALUEFUNC(_wrap_VertexElement_getBestColourVertexElementType), -1);
  rb_define_method(SwigClassVertexElement.klass, "==", VALUEFUNC(_wrap_VertexElement___eq__), -1);
  rb_define_method(SwigClassVertexElement.klass, "baseVertexPointerToElement", VALUEFUNC(_wrap_VertexElement_baseVertexPointerToElement), -1);
  SwigClassVertexElement.mark = 0;
  SwigClassVertexElement.destroy = (void (*)(void *)) free_Ogre_VertexElement;
  SwigClassVertexElement.trackObjects = 0;
  
  SwigClassVertexDeclaration.klass = rb_define_class_under(mOgre, "VertexDeclaration", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexDeclaration, (void *) &SwigClassVertexDeclaration);
  rb_define_alloc_func(SwigClassVertexDeclaration.klass, _wrap_VertexDeclaration_allocate);
  rb_define_method(SwigClassVertexDeclaration.klass, "initialize", VALUEFUNC(_wrap_new_VertexDeclaration), -1);
  rb_define_singleton_method(SwigClassVertexDeclaration.klass, "vertexElementLess", VALUEFUNC(_wrap_VertexDeclaration_vertexElementLess), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "getElementCount", VALUEFUNC(_wrap_VertexDeclaration_getElementCount), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "getElements", VALUEFUNC(_wrap_VertexDeclaration_getElements), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "getElement", VALUEFUNC(_wrap_VertexDeclaration_getElement), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "sort", VALUEFUNC(_wrap_VertexDeclaration_sort), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "closeGapsInSource", VALUEFUNC(_wrap_VertexDeclaration_closeGapsInSource), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "getAutoOrganisedDeclaration", VALUEFUNC(_wrap_VertexDeclaration_getAutoOrganisedDeclaration), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "getMaxSource", VALUEFUNC(_wrap_VertexDeclaration_getMaxSource), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "addElement", VALUEFUNC(_wrap_VertexDeclaration_addElement), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "insertElement", VALUEFUNC(_wrap_VertexDeclaration_insertElement), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "removeElement", VALUEFUNC(_wrap_VertexDeclaration_removeElement), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "removeAllElements", VALUEFUNC(_wrap_VertexDeclaration_removeAllElements), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "modifyElement", VALUEFUNC(_wrap_VertexDeclaration_modifyElement), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "findElementBySemantic", VALUEFUNC(_wrap_VertexDeclaration_findElementBySemantic), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "findElementsBySource", VALUEFUNC(_wrap_VertexDeclaration_findElementsBySource), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "getVertexSize", VALUEFUNC(_wrap_VertexDeclaration_getVertexSize), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "getNextFreeTextureCoordinate", VALUEFUNC(_wrap_VertexDeclaration_getNextFreeTextureCoordinate), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "clone", VALUEFUNC(_wrap_VertexDeclaration_clone), -1);
  rb_define_method(SwigClassVertexDeclaration.klass, "==", VALUEFUNC(_wrap_VertexDeclaration___eq__), -1);
  SwigClassVertexDeclaration.mark = 0;
  SwigClassVertexDeclaration.destroy = (void (*)(void *)) free_Ogre_VertexDeclaration;
  SwigClassVertexDeclaration.trackObjects = 0;
  
  SwigClassVertexBufferBinding.klass = rb_define_class_under(mOgre, "VertexBufferBinding", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexBufferBinding, (void *) &SwigClassVertexBufferBinding);
  rb_define_alloc_func(SwigClassVertexBufferBinding.klass, _wrap_VertexBufferBinding_allocate);
  rb_define_method(SwigClassVertexBufferBinding.klass, "initialize", VALUEFUNC(_wrap_new_VertexBufferBinding), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "setBinding", VALUEFUNC(_wrap_VertexBufferBinding_setBinding), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "unsetBinding", VALUEFUNC(_wrap_VertexBufferBinding_unsetBinding), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "unsetAllBindings", VALUEFUNC(_wrap_VertexBufferBinding_unsetAllBindings), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "getBindings", VALUEFUNC(_wrap_VertexBufferBinding_getBindings), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "getBuffer", VALUEFUNC(_wrap_VertexBufferBinding_getBuffer), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "isBufferBound", VALUEFUNC(_wrap_VertexBufferBinding_isBufferBound), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "getBufferCount", VALUEFUNC(_wrap_VertexBufferBinding_getBufferCount), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "getNextIndex", VALUEFUNC(_wrap_VertexBufferBinding_getNextIndex), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "getLastBoundIndex", VALUEFUNC(_wrap_VertexBufferBinding_getLastBoundIndex), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "hasGaps", VALUEFUNC(_wrap_VertexBufferBinding_hasGaps), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "closeGaps", VALUEFUNC(_wrap_VertexBufferBinding_closeGaps), -1);
  rb_define_method(SwigClassVertexBufferBinding.klass, "getHasInstanceData", VALUEFUNC(_wrap_VertexBufferBinding_getHasInstanceData), -1);
  SwigClassVertexBufferBinding.mark = 0;
  SwigClassVertexBufferBinding.destroy = (void (*)(void *)) free_Ogre_VertexBufferBinding;
  SwigClassVertexBufferBinding.trackObjects = 0;
  
  SwigClassKeyFrame.klass = rb_define_class_under(mOgre, "KeyFrame", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__KeyFrame, (void *) &SwigClassKeyFrame);
  rb_define_alloc_func(SwigClassKeyFrame.klass, _wrap_KeyFrame_allocate);
  rb_define_method(SwigClassKeyFrame.klass, "initialize", VALUEFUNC(_wrap_new_KeyFrame), -1);
  rb_define_method(SwigClassKeyFrame.klass, "getTime", VALUEFUNC(_wrap_KeyFrame_getTime), -1);
  rb_define_method(SwigClassKeyFrame.klass, "_clone", VALUEFUNC(_wrap_KeyFrame__clone), -1);
  SwigClassKeyFrame.mark = 0;
  SwigClassKeyFrame.destroy = (void (*)(void *)) free_Ogre_KeyFrame;
  SwigClassKeyFrame.trackObjects = 0;
  
  SwigClassNumericKeyFrame.klass = rb_define_class_under(mOgre, "NumericKeyFrame", ((swig_class *) SWIGTYPE_p_Ogre__KeyFrame->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__NumericKeyFrame, (void *) &SwigClassNumericKeyFrame);
  rb_define_alloc_func(SwigClassNumericKeyFrame.klass, _wrap_NumericKeyFrame_allocate);
  rb_define_method(SwigClassNumericKeyFrame.klass, "initialize", VALUEFUNC(_wrap_new_NumericKeyFrame), -1);
  rb_define_method(SwigClassNumericKeyFrame.klass, "getValue", VALUEFUNC(_wrap_NumericKeyFrame_getValue), -1);
  rb_define_method(SwigClassNumericKeyFrame.klass, "setValue", VALUEFUNC(_wrap_NumericKeyFrame_setValue), -1);
  rb_define_method(SwigClassNumericKeyFrame.klass, "_clone", VALUEFUNC(_wrap_NumericKeyFrame__clone), -1);
  SwigClassNumericKeyFrame.mark = 0;
  SwigClassNumericKeyFrame.destroy = (void (*)(void *)) free_Ogre_NumericKeyFrame;
  SwigClassNumericKeyFrame.trackObjects = 0;
  
  SwigClassTransformKeyFrame.klass = rb_define_class_under(mOgre, "TransformKeyFrame", ((swig_class *) SWIGTYPE_p_Ogre__KeyFrame->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TransformKeyFrame, (void *) &SwigClassTransformKeyFrame);
  rb_define_alloc_func(SwigClassTransformKeyFrame.klass, _wrap_TransformKeyFrame_allocate);
  rb_define_method(SwigClassTransformKeyFrame.klass, "initialize", VALUEFUNC(_wrap_new_TransformKeyFrame), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "setTranslate", VALUEFUNC(_wrap_TransformKeyFrame_setTranslate), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "getTranslate", VALUEFUNC(_wrap_TransformKeyFrame_getTranslate), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "setScale", VALUEFUNC(_wrap_TransformKeyFrame_setScale), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "getScale", VALUEFUNC(_wrap_TransformKeyFrame_getScale), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "setRotation", VALUEFUNC(_wrap_TransformKeyFrame_setRotation), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "getRotation", VALUEFUNC(_wrap_TransformKeyFrame_getRotation), -1);
  rb_define_method(SwigClassTransformKeyFrame.klass, "_clone", VALUEFUNC(_wrap_TransformKeyFrame__clone), -1);
  SwigClassTransformKeyFrame.mark = 0;
  SwigClassTransformKeyFrame.destroy = (void (*)(void *)) free_Ogre_TransformKeyFrame;
  SwigClassTransformKeyFrame.trackObjects = 0;
  
  SwigClassVertexMorphKeyFrame.klass = rb_define_class_under(mOgre, "VertexMorphKeyFrame", ((swig_class *) SWIGTYPE_p_Ogre__KeyFrame->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexMorphKeyFrame, (void *) &SwigClassVertexMorphKeyFrame);
  rb_define_alloc_func(SwigClassVertexMorphKeyFrame.klass, _wrap_VertexMorphKeyFrame_allocate);
  rb_define_method(SwigClassVertexMorphKeyFrame.klass, "initialize", VALUEFUNC(_wrap_new_VertexMorphKeyFrame), -1);
  rb_define_method(SwigClassVertexMorphKeyFrame.klass, "setVertexBuffer", VALUEFUNC(_wrap_VertexMorphKeyFrame_setVertexBuffer), -1);
  rb_define_method(SwigClassVertexMorphKeyFrame.klass, "getVertexBuffer", VALUEFUNC(_wrap_VertexMorphKeyFrame_getVertexBuffer), -1);
  rb_define_method(SwigClassVertexMorphKeyFrame.klass, "_clone", VALUEFUNC(_wrap_VertexMorphKeyFrame__clone), -1);
  SwigClassVertexMorphKeyFrame.mark = 0;
  SwigClassVertexMorphKeyFrame.destroy = (void (*)(void *)) free_Ogre_VertexMorphKeyFrame;
  SwigClassVertexMorphKeyFrame.trackObjects = 0;
  
  SwigClassVertexPoseKeyFrame.klass = rb_define_class_under(mOgre, "VertexPoseKeyFrame", ((swig_class *) SWIGTYPE_p_Ogre__KeyFrame->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexPoseKeyFrame, (void *) &SwigClassVertexPoseKeyFrame);
  rb_define_alloc_func(SwigClassVertexPoseKeyFrame.klass, _wrap_VertexPoseKeyFrame_allocate);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "initialize", VALUEFUNC(_wrap_new_VertexPoseKeyFrame), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "addPoseReference", VALUEFUNC(_wrap_VertexPoseKeyFrame_addPoseReference), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "updatePoseReference", VALUEFUNC(_wrap_VertexPoseKeyFrame_updatePoseReference), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "removePoseReference", VALUEFUNC(_wrap_VertexPoseKeyFrame_removePoseReference), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "removeAllPoseReferences", VALUEFUNC(_wrap_VertexPoseKeyFrame_removeAllPoseReferences), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "getPoseReferences", VALUEFUNC(_wrap_VertexPoseKeyFrame_getPoseReferences), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "getPoseReferenceIterator", VALUEFUNC(_wrap_VertexPoseKeyFrame_getPoseReferenceIterator), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "_clone", VALUEFUNC(_wrap_VertexPoseKeyFrame__clone), -1);
  rb_define_method(SwigClassVertexPoseKeyFrame.klass, "_applyBaseKeyFrame", VALUEFUNC(_wrap_VertexPoseKeyFrame__applyBaseKeyFrame), -1);
  SwigClassVertexPoseKeyFrame.mark = 0;
  SwigClassVertexPoseKeyFrame.destroy = (void (*)(void *)) free_Ogre_VertexPoseKeyFrame;
  SwigClassVertexPoseKeyFrame.trackObjects = 0;
  
  SwigClassPose.klass = rb_define_class_under(mOgre, "Pose", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Pose, (void *) &SwigClassPose);
  rb_define_alloc_func(SwigClassPose.klass, _wrap_Pose_allocate);
  rb_define_method(SwigClassPose.klass, "initialize", VALUEFUNC(_wrap_new_Pose), -1);
  rb_define_method(SwigClassPose.klass, "getName", VALUEFUNC(_wrap_Pose_getName), -1);
  rb_define_method(SwigClassPose.klass, "getTarget", VALUEFUNC(_wrap_Pose_getTarget), -1);
  rb_define_method(SwigClassPose.klass, "getIncludesNormals", VALUEFUNC(_wrap_Pose_getIncludesNormals), -1);
  rb_define_method(SwigClassPose.klass, "addVertex", VALUEFUNC(_wrap_Pose_addVertex), -1);
  rb_define_method(SwigClassPose.klass, "removeVertex", VALUEFUNC(_wrap_Pose_removeVertex), -1);
  rb_define_method(SwigClassPose.klass, "clearVertices", VALUEFUNC(_wrap_Pose_clearVertices), -1);
  rb_define_method(SwigClassPose.klass, "getVertexOffsetIterator", VALUEFUNC(_wrap_Pose_getVertexOffsetIterator), -1);
  rb_define_method(SwigClassPose.klass, "getVertexOffsets", VALUEFUNC(_wrap_Pose_getVertexOffsets), -1);
  rb_define_method(SwigClassPose.klass, "getNormalsIterator", VALUEFUNC(_wrap_Pose_getNormalsIterator), -1);
  rb_define_method(SwigClassPose.klass, "getNormals", VALUEFUNC(_wrap_Pose_getNormals), -1);
  rb_define_method(SwigClassPose.klass, "_getHardwareVertexBuffer", VALUEFUNC(_wrap_Pose__getHardwareVertexBuffer), -1);
  rb_define_method(SwigClassPose.klass, "clone", VALUEFUNC(_wrap_Pose_clone), -1);
  SwigClassPose.mark = 0;
  SwigClassPose.destroy = (void (*)(void *)) free_Ogre_Pose;
  SwigClassPose.trackObjects = 0;
  
  SwigClassTimeIndex.klass = rb_define_class_under(mOgre, "TimeIndex", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TimeIndex, (void *) &SwigClassTimeIndex);
  rb_define_alloc_func(SwigClassTimeIndex.klass, _wrap_TimeIndex_allocate);
  rb_define_method(SwigClassTimeIndex.klass, "initialize", VALUEFUNC(_wrap_new_TimeIndex), -1);
  rb_define_method(SwigClassTimeIndex.klass, "hasKeyIndex", VALUEFUNC(_wrap_TimeIndex_hasKeyIndex), -1);
  rb_define_method(SwigClassTimeIndex.klass, "getTimePos", VALUEFUNC(_wrap_TimeIndex_getTimePos), -1);
  rb_define_method(SwigClassTimeIndex.klass, "getKeyIndex", VALUEFUNC(_wrap_TimeIndex_getKeyIndex), -1);
  SwigClassTimeIndex.mark = 0;
  SwigClassTimeIndex.destroy = (void (*)(void *)) free_Ogre_TimeIndex;
  SwigClassTimeIndex.trackObjects = 0;
  
  SwigClassAnimationTrack.klass = rb_define_class_under(mOgre, "AnimationTrack", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimationTrack, (void *) &SwigClassAnimationTrack);
  rb_undef_alloc_func(SwigClassAnimationTrack.klass);
  rb_define_method(SwigClassAnimationTrack.klass, "getHandle", VALUEFUNC(_wrap_AnimationTrack_getHandle), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "getNumKeyFrames", VALUEFUNC(_wrap_AnimationTrack_getNumKeyFrames), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "getKeyFrame", VALUEFUNC(_wrap_AnimationTrack_getKeyFrame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "getKeyFramesAtTime", VALUEFUNC(_wrap_AnimationTrack_getKeyFramesAtTime), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "createKeyFrame", VALUEFUNC(_wrap_AnimationTrack_createKeyFrame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "removeKeyFrame", VALUEFUNC(_wrap_AnimationTrack_removeKeyFrame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "removeAllKeyFrames", VALUEFUNC(_wrap_AnimationTrack_removeAllKeyFrames), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "getInterpolatedKeyFrame", VALUEFUNC(_wrap_AnimationTrack_getInterpolatedKeyFrame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "apply", VALUEFUNC(_wrap_AnimationTrack_apply), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_keyFrameDataChanged", VALUEFUNC(_wrap_AnimationTrack__keyFrameDataChanged), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "hasNonZeroKeyFrames", VALUEFUNC(_wrap_AnimationTrack_hasNonZeroKeyFrames), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "optimise", VALUEFUNC(_wrap_AnimationTrack_optimise), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_collectKeyFrameTimes", VALUEFUNC(_wrap_AnimationTrack__collectKeyFrameTimes), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_buildKeyFrameIndexMap", VALUEFUNC(_wrap_AnimationTrack__buildKeyFrameIndexMap), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "_applyBaseKeyFrame", VALUEFUNC(_wrap_AnimationTrack__applyBaseKeyFrame), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "setListener", VALUEFUNC(_wrap_AnimationTrack_setListener), -1);
  rb_define_method(SwigClassAnimationTrack.klass, "getParent", VALUEFUNC(_wrap_AnimationTrack_getParent), -1);
  SwigClassAnimationTrack.mark = 0;
  SwigClassAnimationTrack.destroy = (void (*)(void *)) free_Ogre_AnimationTrack;
  SwigClassAnimationTrack.trackObjects = 0;
  
  SwigClassNumericAnimationTrack.klass = rb_define_class_under(mOgre, "NumericAnimationTrack", ((swig_class *) SWIGTYPE_p_Ogre__AnimationTrack->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__NumericAnimationTrack, (void *) &SwigClassNumericAnimationTrack);
  rb_define_alloc_func(SwigClassNumericAnimationTrack.klass, _wrap_NumericAnimationTrack_allocate);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "initialize", VALUEFUNC(_wrap_new_NumericAnimationTrack), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "createNumericKeyFrame", VALUEFUNC(_wrap_NumericAnimationTrack_createNumericKeyFrame), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "getInterpolatedKeyFrame", VALUEFUNC(_wrap_NumericAnimationTrack_getInterpolatedKeyFrame), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "apply", VALUEFUNC(_wrap_NumericAnimationTrack_apply), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "applyToAnimable", VALUEFUNC(_wrap_NumericAnimationTrack_applyToAnimable), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "getAssociatedAnimable", VALUEFUNC(_wrap_NumericAnimationTrack_getAssociatedAnimable), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "setAssociatedAnimable", VALUEFUNC(_wrap_NumericAnimationTrack_setAssociatedAnimable), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "getNumericKeyFrame", VALUEFUNC(_wrap_NumericAnimationTrack_getNumericKeyFrame), -1);
  rb_define_method(SwigClassNumericAnimationTrack.klass, "_clone", VALUEFUNC(_wrap_NumericAnimationTrack__clone), -1);
  SwigClassNumericAnimationTrack.mark = 0;
  SwigClassNumericAnimationTrack.destroy = (void (*)(void *)) free_Ogre_NumericAnimationTrack;
  SwigClassNumericAnimationTrack.trackObjects = 0;
  
  SwigClassNodeAnimationTrack.klass = rb_define_class_under(mOgre, "NodeAnimationTrack", ((swig_class *) SWIGTYPE_p_Ogre__AnimationTrack->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__NodeAnimationTrack, (void *) &SwigClassNodeAnimationTrack);
  rb_define_alloc_func(SwigClassNodeAnimationTrack.klass, _wrap_NodeAnimationTrack_allocate);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "initialize", VALUEFUNC(_wrap_new_NodeAnimationTrack), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "createNodeKeyFrame", VALUEFUNC(_wrap_NodeAnimationTrack_createNodeKeyFrame), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "getAssociatedNode", VALUEFUNC(_wrap_NodeAnimationTrack_getAssociatedNode), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "setAssociatedNode", VALUEFUNC(_wrap_NodeAnimationTrack_setAssociatedNode), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "applyToNode", VALUEFUNC(_wrap_NodeAnimationTrack_applyToNode), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "setUseShortestRotationPath", VALUEFUNC(_wrap_NodeAnimationTrack_setUseShortestRotationPath), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "getUseShortestRotationPath", VALUEFUNC(_wrap_NodeAnimationTrack_getUseShortestRotationPath), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "getInterpolatedKeyFrame", VALUEFUNC(_wrap_NodeAnimationTrack_getInterpolatedKeyFrame), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "apply", VALUEFUNC(_wrap_NodeAnimationTrack_apply), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "_keyFrameDataChanged", VALUEFUNC(_wrap_NodeAnimationTrack__keyFrameDataChanged), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "getNodeKeyFrame", VALUEFUNC(_wrap_NodeAnimationTrack_getNodeKeyFrame), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "hasNonZeroKeyFrames", VALUEFUNC(_wrap_NodeAnimationTrack_hasNonZeroKeyFrames), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "optimise", VALUEFUNC(_wrap_NodeAnimationTrack_optimise), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "_clone", VALUEFUNC(_wrap_NodeAnimationTrack__clone), -1);
  rb_define_method(SwigClassNodeAnimationTrack.klass, "_applyBaseKeyFrame", VALUEFUNC(_wrap_NodeAnimationTrack__applyBaseKeyFrame), -1);
  SwigClassNodeAnimationTrack.mark = 0;
  SwigClassNodeAnimationTrack.destroy = (void (*)(void *)) free_Ogre_NodeAnimationTrack;
  SwigClassNodeAnimationTrack.trackObjects = 0;
  rb_define_const(mOgre, "VAT_NONE", SWIG_From_int(static_cast< int >(Ogre::VAT_NONE)));
  rb_define_const(mOgre, "VAT_MORPH", SWIG_From_int(static_cast< int >(Ogre::VAT_MORPH)));
  rb_define_const(mOgre, "VAT_POSE", SWIG_From_int(static_cast< int >(Ogre::VAT_POSE)));
  
  SwigClassVertexAnimationTrack.klass = rb_define_class_under(mOgre, "VertexAnimationTrack", ((swig_class *) SWIGTYPE_p_Ogre__AnimationTrack->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexAnimationTrack, (void *) &SwigClassVertexAnimationTrack);
  rb_define_alloc_func(SwigClassVertexAnimationTrack.klass, _wrap_VertexAnimationTrack_allocate);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "initialize", VALUEFUNC(_wrap_new_VertexAnimationTrack), -1);
  rb_define_const(SwigClassVertexAnimationTrack.klass, "TM_SOFTWARE", SWIG_From_int(static_cast< int >(Ogre::VertexAnimationTrack::TM_SOFTWARE)));
  rb_define_const(SwigClassVertexAnimationTrack.klass, "TM_HARDWARE", SWIG_From_int(static_cast< int >(Ogre::VertexAnimationTrack::TM_HARDWARE)));
  rb_define_method(SwigClassVertexAnimationTrack.klass, "getAnimationType", VALUEFUNC(_wrap_VertexAnimationTrack_getAnimationType), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "getVertexAnimationIncludesNormals", VALUEFUNC(_wrap_VertexAnimationTrack_getVertexAnimationIncludesNormals), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "createVertexMorphKeyFrame", VALUEFUNC(_wrap_VertexAnimationTrack_createVertexMorphKeyFrame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "createVertexPoseKeyFrame", VALUEFUNC(_wrap_VertexAnimationTrack_createVertexPoseKeyFrame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "getInterpolatedKeyFrame", VALUEFUNC(_wrap_VertexAnimationTrack_getInterpolatedKeyFrame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "apply", VALUEFUNC(_wrap_VertexAnimationTrack_apply), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "applyToVertexData", VALUEFUNC(_wrap_VertexAnimationTrack_applyToVertexData), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "getVertexMorphKeyFrame", VALUEFUNC(_wrap_VertexAnimationTrack_getVertexMorphKeyFrame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "getVertexPoseKeyFrame", VALUEFUNC(_wrap_VertexAnimationTrack_getVertexPoseKeyFrame), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "setAssociatedVertexData", VALUEFUNC(_wrap_VertexAnimationTrack_setAssociatedVertexData), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "getAssociatedVertexData", VALUEFUNC(_wrap_VertexAnimationTrack_getAssociatedVertexData), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "setTargetMode", VALUEFUNC(_wrap_VertexAnimationTrack_setTargetMode), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "getTargetMode", VALUEFUNC(_wrap_VertexAnimationTrack_getTargetMode), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "hasNonZeroKeyFrames", VALUEFUNC(_wrap_VertexAnimationTrack_hasNonZeroKeyFrames), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "optimise", VALUEFUNC(_wrap_VertexAnimationTrack_optimise), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "_clone", VALUEFUNC(_wrap_VertexAnimationTrack__clone), -1);
  rb_define_method(SwigClassVertexAnimationTrack.klass, "_applyBaseKeyFrame", VALUEFUNC(_wrap_VertexAnimationTrack__applyBaseKeyFrame), -1);
  SwigClassVertexAnimationTrack.mark = 0;
  SwigClassVertexAnimationTrack.destroy = (void (*)(void *)) free_Ogre_VertexAnimationTrack;
  SwigClassVertexAnimationTrack.trackObjects = 0;
  
  SwigClassAnimationState.klass = rb_define_class_under(mOgre, "AnimationState", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimationState, (void *) &SwigClassAnimationState);
  rb_define_alloc_func(SwigClassAnimationState.klass, _wrap_AnimationState_allocate);
  rb_define_method(SwigClassAnimationState.klass, "initialize", VALUEFUNC(_wrap_new_AnimationState), -1);
  rb_define_method(SwigClassAnimationState.klass, "getAnimationName", VALUEFUNC(_wrap_AnimationState_getAnimationName), -1);
  rb_define_method(SwigClassAnimationState.klass, "getTimePosition", VALUEFUNC(_wrap_AnimationState_getTimePosition), -1);
  rb_define_method(SwigClassAnimationState.klass, "setTimePosition", VALUEFUNC(_wrap_AnimationState_setTimePosition), -1);
  rb_define_method(SwigClassAnimationState.klass, "getLength", VALUEFUNC(_wrap_AnimationState_getLength), -1);
  rb_define_method(SwigClassAnimationState.klass, "setLength", VALUEFUNC(_wrap_AnimationState_setLength), -1);
  rb_define_method(SwigClassAnimationState.klass, "getWeight", VALUEFUNC(_wrap_AnimationState_getWeight), -1);
  rb_define_method(SwigClassAnimationState.klass, "setWeight", VALUEFUNC(_wrap_AnimationState_setWeight), -1);
  rb_define_method(SwigClassAnimationState.klass, "addTime", VALUEFUNC(_wrap_AnimationState_addTime), -1);
  rb_define_method(SwigClassAnimationState.klass, "hasEnded", VALUEFUNC(_wrap_AnimationState_hasEnded), -1);
  rb_define_method(SwigClassAnimationState.klass, "getEnabled", VALUEFUNC(_wrap_AnimationState_getEnabled), -1);
  rb_define_method(SwigClassAnimationState.klass, "setEnabled", VALUEFUNC(_wrap_AnimationState_setEnabled), -1);
  rb_define_method(SwigClassAnimationState.klass, "==", VALUEFUNC(_wrap_AnimationState___eq__), -1);
  rb_define_method(SwigClassAnimationState.klass, "setLoop", VALUEFUNC(_wrap_AnimationState_setLoop), -1);
  rb_define_method(SwigClassAnimationState.klass, "getLoop", VALUEFUNC(_wrap_AnimationState_getLoop), -1);
  rb_define_method(SwigClassAnimationState.klass, "copyStateFrom", VALUEFUNC(_wrap_AnimationState_copyStateFrom), -1);
  rb_define_method(SwigClassAnimationState.klass, "getParent", VALUEFUNC(_wrap_AnimationState_getParent), -1);
  rb_define_method(SwigClassAnimationState.klass, "createBlendMask", VALUEFUNC(_wrap_AnimationState_createBlendMask), -1);
  rb_define_method(SwigClassAnimationState.klass, "destroyBlendMask", VALUEFUNC(_wrap_AnimationState_destroyBlendMask), -1);
  rb_define_method(SwigClassAnimationState.klass, "_setBlendMaskData", VALUEFUNC(_wrap_AnimationState__setBlendMaskData), -1);
  rb_define_method(SwigClassAnimationState.klass, "_setBlendMask", VALUEFUNC(_wrap_AnimationState__setBlendMask), -1);
  rb_define_method(SwigClassAnimationState.klass, "getBlendMask", VALUEFUNC(_wrap_AnimationState_getBlendMask), -1);
  rb_define_method(SwigClassAnimationState.klass, "hasBlendMask", VALUEFUNC(_wrap_AnimationState_hasBlendMask), -1);
  rb_define_method(SwigClassAnimationState.klass, "setBlendMaskEntry", VALUEFUNC(_wrap_AnimationState_setBlendMaskEntry), -1);
  rb_define_method(SwigClassAnimationState.klass, "getBlendMaskEntry", VALUEFUNC(_wrap_AnimationState_getBlendMaskEntry), -1);
  SwigClassAnimationState.mark = 0;
  SwigClassAnimationState.destroy = (void (*)(void *)) free_Ogre_AnimationState;
  SwigClassAnimationState.trackObjects = 0;
  
  SwigClassAnimationStateSet.klass = rb_define_class_under(mOgre, "AnimationStateSet", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimationStateSet, (void *) &SwigClassAnimationStateSet);
  rb_define_alloc_func(SwigClassAnimationStateSet.klass, _wrap_AnimationStateSet_allocate);
  rb_define_method(SwigClassAnimationStateSet.klass, "initialize", VALUEFUNC(_wrap_new_AnimationStateSet), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "createAnimationState", VALUEFUNC(_wrap_AnimationStateSet_createAnimationState), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "getAnimationState", VALUEFUNC(_wrap_AnimationStateSet_getAnimationState), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "hasAnimationState", VALUEFUNC(_wrap_AnimationStateSet_hasAnimationState), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "removeAnimationState", VALUEFUNC(_wrap_AnimationStateSet_removeAnimationState), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "removeAllAnimationStates", VALUEFUNC(_wrap_AnimationStateSet_removeAllAnimationStates), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "getAnimationStateIterator", VALUEFUNC(_wrap_AnimationStateSet_getAnimationStateIterator), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "copyMatchingState", VALUEFUNC(_wrap_AnimationStateSet_copyMatchingState), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "_notifyDirty", VALUEFUNC(_wrap_AnimationStateSet__notifyDirty), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "getDirtyFrameNumber", VALUEFUNC(_wrap_AnimationStateSet_getDirtyFrameNumber), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "_notifyAnimationStateEnabled", VALUEFUNC(_wrap_AnimationStateSet__notifyAnimationStateEnabled), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "hasEnabledAnimationState", VALUEFUNC(_wrap_AnimationStateSet_hasEnabledAnimationState), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "getEnabledAnimationStateIterator", VALUEFUNC(_wrap_AnimationStateSet_getEnabledAnimationStateIterator), -1);
  rb_define_method(SwigClassAnimationStateSet.klass, "each_AnimationState", VALUEFUNC(_wrap_AnimationStateSet_each_AnimationState), -1);
  SwigClassAnimationStateSet.mark = 0;
  SwigClassAnimationStateSet.destroy = (void (*)(void *)) free_Ogre_AnimationStateSet;
  SwigClassAnimationStateSet.trackObjects = 0;
  
  SwigClassAnimationStateControllerValue.klass = rb_define_class_under(mOgre, "AnimationStateControllerValue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimationStateControllerValue, (void *) &SwigClassAnimationStateControllerValue);
  rb_define_alloc_func(SwigClassAnimationStateControllerValue.klass, _wrap_AnimationStateControllerValue_allocate);
  rb_define_method(SwigClassAnimationStateControllerValue.klass, "initialize", VALUEFUNC(_wrap_new_AnimationStateControllerValue), -1);
  rb_define_method(SwigClassAnimationStateControllerValue.klass, "getValue", VALUEFUNC(_wrap_AnimationStateControllerValue_getValue), -1);
  rb_define_method(SwigClassAnimationStateControllerValue.klass, "setValue", VALUEFUNC(_wrap_AnimationStateControllerValue_setValue), -1);
  SwigClassAnimationStateControllerValue.mark = 0;
  SwigClassAnimationStateControllerValue.destroy = (void (*)(void *)) free_Ogre_AnimationStateControllerValue;
  SwigClassAnimationStateControllerValue.trackObjects = 0;
  
  SwigClassAnimationContainer.klass = rb_define_class_under(mOgre, "AnimationContainer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimationContainer, (void *) &SwigClassAnimationContainer);
  rb_undef_alloc_func(SwigClassAnimationContainer.klass);
  rb_define_method(SwigClassAnimationContainer.klass, "getNumAnimations", VALUEFUNC(_wrap_AnimationContainer_getNumAnimations), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "getAnimation", VALUEFUNC(_wrap_AnimationContainer_getAnimation), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "createAnimation", VALUEFUNC(_wrap_AnimationContainer_createAnimation), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "hasAnimation", VALUEFUNC(_wrap_AnimationContainer_hasAnimation), -1);
  rb_define_method(SwigClassAnimationContainer.klass, "removeAnimation", VALUEFUNC(_wrap_AnimationContainer_removeAnimation), -1);
  SwigClassAnimationContainer.mark = 0;
  SwigClassAnimationContainer.destroy = (void (*)(void *)) free_Ogre_AnimationContainer;
  SwigClassAnimationContainer.trackObjects = 0;
  
  SwigClassAnimation.klass = rb_define_class_under(mOgre, "Animation", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Animation, (void *) &SwigClassAnimation);
  rb_define_alloc_func(SwigClassAnimation.klass, _wrap_Animation_allocate);
  rb_define_method(SwigClassAnimation.klass, "initialize", VALUEFUNC(_wrap_new_Animation), -1);
  rb_define_const(SwigClassAnimation.klass, "IM_LINEAR", SWIG_From_int(static_cast< int >(Ogre::Animation::IM_LINEAR)));
  rb_define_const(SwigClassAnimation.klass, "IM_SPLINE", SWIG_From_int(static_cast< int >(Ogre::Animation::IM_SPLINE)));
  rb_define_const(SwigClassAnimation.klass, "RIM_LINEAR", SWIG_From_int(static_cast< int >(Ogre::Animation::RIM_LINEAR)));
  rb_define_const(SwigClassAnimation.klass, "RIM_SPHERICAL", SWIG_From_int(static_cast< int >(Ogre::Animation::RIM_SPHERICAL)));
  rb_define_method(SwigClassAnimation.klass, "getName", VALUEFUNC(_wrap_Animation_getName), -1);
  rb_define_method(SwigClassAnimation.klass, "getLength", VALUEFUNC(_wrap_Animation_getLength), -1);
  rb_define_method(SwigClassAnimation.klass, "setLength", VALUEFUNC(_wrap_Animation_setLength), -1);
  rb_define_method(SwigClassAnimation.klass, "createNodeTrack", VALUEFUNC(_wrap_Animation_createNodeTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "createNumericTrack", VALUEFUNC(_wrap_Animation_createNumericTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "createVertexTrack", VALUEFUNC(_wrap_Animation_createVertexTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "getNumNodeTracks", VALUEFUNC(_wrap_Animation_getNumNodeTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "getNodeTrack", VALUEFUNC(_wrap_Animation_getNodeTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "hasNodeTrack", VALUEFUNC(_wrap_Animation_hasNodeTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "getNumNumericTracks", VALUEFUNC(_wrap_Animation_getNumNumericTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "getNumericTrack", VALUEFUNC(_wrap_Animation_getNumericTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "hasNumericTrack", VALUEFUNC(_wrap_Animation_hasNumericTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "getNumVertexTracks", VALUEFUNC(_wrap_Animation_getNumVertexTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "getVertexTrack", VALUEFUNC(_wrap_Animation_getVertexTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "hasVertexTrack", VALUEFUNC(_wrap_Animation_hasVertexTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "destroyNodeTrack", VALUEFUNC(_wrap_Animation_destroyNodeTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "destroyNumericTrack", VALUEFUNC(_wrap_Animation_destroyNumericTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "destroyVertexTrack", VALUEFUNC(_wrap_Animation_destroyVertexTrack), -1);
  rb_define_method(SwigClassAnimation.klass, "destroyAllTracks", VALUEFUNC(_wrap_Animation_destroyAllTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "destroyAllNodeTracks", VALUEFUNC(_wrap_Animation_destroyAllNodeTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "destroyAllNumericTracks", VALUEFUNC(_wrap_Animation_destroyAllNumericTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "destroyAllVertexTracks", VALUEFUNC(_wrap_Animation_destroyAllVertexTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "applyToNode", VALUEFUNC(_wrap_Animation_applyToNode), -1);
  rb_define_method(SwigClassAnimation.klass, "apply", VALUEFUNC(_wrap_Animation_apply), -1);
  rb_define_method(SwigClassAnimation.klass, "applyToAnimable", VALUEFUNC(_wrap_Animation_applyToAnimable), -1);
  rb_define_method(SwigClassAnimation.klass, "applyToVertexData", VALUEFUNC(_wrap_Animation_applyToVertexData), -1);
  rb_define_method(SwigClassAnimation.klass, "setInterpolationMode", VALUEFUNC(_wrap_Animation_setInterpolationMode), -1);
  rb_define_method(SwigClassAnimation.klass, "getInterpolationMode", VALUEFUNC(_wrap_Animation_getInterpolationMode), -1);
  rb_define_method(SwigClassAnimation.klass, "setRotationInterpolationMode", VALUEFUNC(_wrap_Animation_setRotationInterpolationMode), -1);
  rb_define_method(SwigClassAnimation.klass, "getRotationInterpolationMode", VALUEFUNC(_wrap_Animation_getRotationInterpolationMode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "setDefaultInterpolationMode", VALUEFUNC(_wrap_Animation_setDefaultInterpolationMode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "getDefaultInterpolationMode", VALUEFUNC(_wrap_Animation_getDefaultInterpolationMode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "setDefaultRotationInterpolationMode", VALUEFUNC(_wrap_Animation_setDefaultRotationInterpolationMode), -1);
  rb_define_singleton_method(SwigClassAnimation.klass, "getDefaultRotationInterpolationMode", VALUEFUNC(_wrap_Animation_getDefaultRotationInterpolationMode), -1);
  rb_define_method(SwigClassAnimation.klass, "_getNodeTrackList", VALUEFUNC(_wrap_Animation__getNodeTrackList), -1);
  rb_define_method(SwigClassAnimation.klass, "getNodeTrackIterator", VALUEFUNC(_wrap_Animation_getNodeTrackIterator), -1);
  rb_define_method(SwigClassAnimation.klass, "_getNumericTrackList", VALUEFUNC(_wrap_Animation__getNumericTrackList), -1);
  rb_define_method(SwigClassAnimation.klass, "getNumericTrackIterator", VALUEFUNC(_wrap_Animation_getNumericTrackIterator), -1);
  rb_define_method(SwigClassAnimation.klass, "_getVertexTrackList", VALUEFUNC(_wrap_Animation__getVertexTrackList), -1);
  rb_define_method(SwigClassAnimation.klass, "getVertexTrackIterator", VALUEFUNC(_wrap_Animation_getVertexTrackIterator), -1);
  rb_define_method(SwigClassAnimation.klass, "optimise", VALUEFUNC(_wrap_Animation_optimise), -1);
  rb_define_method(SwigClassAnimation.klass, "_collectIdentityNodeTracks", VALUEFUNC(_wrap_Animation__collectIdentityNodeTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "_destroyNodeTracks", VALUEFUNC(_wrap_Animation__destroyNodeTracks), -1);
  rb_define_method(SwigClassAnimation.klass, "clone", VALUEFUNC(_wrap_Animation_clone), -1);
  rb_define_method(SwigClassAnimation.klass, "_keyFrameListChanged", VALUEFUNC(_wrap_Animation__keyFrameListChanged), -1);
  rb_define_method(SwigClassAnimation.klass, "_getTimeIndex", VALUEFUNC(_wrap_Animation__getTimeIndex), -1);
  rb_define_method(SwigClassAnimation.klass, "setUseBaseKeyFrame", VALUEFUNC(_wrap_Animation_setUseBaseKeyFrame), -1);
  rb_define_method(SwigClassAnimation.klass, "getUseBaseKeyFrame", VALUEFUNC(_wrap_Animation_getUseBaseKeyFrame), -1);
  rb_define_method(SwigClassAnimation.klass, "getBaseKeyFrameTime", VALUEFUNC(_wrap_Animation_getBaseKeyFrameTime), -1);
  rb_define_method(SwigClassAnimation.klass, "getBaseKeyFrameAnimationName", VALUEFUNC(_wrap_Animation_getBaseKeyFrameAnimationName), -1);
  rb_define_method(SwigClassAnimation.klass, "_applyBaseKeyFrame", VALUEFUNC(_wrap_Animation__applyBaseKeyFrame), -1);
  rb_define_method(SwigClassAnimation.klass, "_notifyContainer", VALUEFUNC(_wrap_Animation__notifyContainer), -1);
  rb_define_method(SwigClassAnimation.klass, "getContainer", VALUEFUNC(_wrap_Animation_getContainer), -1);
  SwigClassAnimation.mark = 0;
  SwigClassAnimation.destroy = (void (*)(void *)) free_Ogre_Animation;
  SwigClassAnimation.trackObjects = 0;
  
  SwigClassDataStream.klass = rb_define_class_under(mOgre, "DataStream", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DataStream, (void *) &SwigClassDataStream);
  rb_undef_alloc_func(SwigClassDataStream.klass);
  rb_define_const(SwigClassDataStream.klass, "READ", SWIG_From_int(static_cast< int >(Ogre::DataStream::READ)));
  rb_define_const(SwigClassDataStream.klass, "WRITE", SWIG_From_int(static_cast< int >(Ogre::DataStream::WRITE)));
  rb_define_method(SwigClassDataStream.klass, "getName", VALUEFUNC(_wrap_DataStream_getName), -1);
  rb_define_method(SwigClassDataStream.klass, "getAccessMode", VALUEFUNC(_wrap_DataStream_getAccessMode), -1);
  rb_define_method(SwigClassDataStream.klass, "isReadable", VALUEFUNC(_wrap_DataStream_isReadable), -1);
  rb_define_method(SwigClassDataStream.klass, "isWriteable", VALUEFUNC(_wrap_DataStream_isWriteable), -1);
  rb_define_method(SwigClassDataStream.klass, "read", VALUEFUNC(_wrap_DataStream_read), -1);
  rb_define_method(SwigClassDataStream.klass, "write", VALUEFUNC(_wrap_DataStream_write), -1);
  rb_define_method(SwigClassDataStream.klass, "readLine", VALUEFUNC(_wrap_DataStream_readLine), -1);
  rb_define_method(SwigClassDataStream.klass, "getLine", VALUEFUNC(_wrap_DataStream_getLine), -1);
  rb_define_method(SwigClassDataStream.klass, "getAsString", VALUEFUNC(_wrap_DataStream_getAsString), -1);
  rb_define_method(SwigClassDataStream.klass, "skipLine", VALUEFUNC(_wrap_DataStream_skipLine), -1);
  rb_define_method(SwigClassDataStream.klass, "skip", VALUEFUNC(_wrap_DataStream_skip), -1);
  rb_define_method(SwigClassDataStream.klass, "seek", VALUEFUNC(_wrap_DataStream_seek), -1);
  rb_define_method(SwigClassDataStream.klass, "tell", VALUEFUNC(_wrap_DataStream_tell), -1);
  rb_define_method(SwigClassDataStream.klass, "eof", VALUEFUNC(_wrap_DataStream_eof), -1);
  rb_define_method(SwigClassDataStream.klass, "size", VALUEFUNC(_wrap_DataStream_size), -1);
  rb_define_method(SwigClassDataStream.klass, "close", VALUEFUNC(_wrap_DataStream_close), -1);
  SwigClassDataStream.mark = 0;
  SwigClassDataStream.destroy = (void (*)(void *)) free_Ogre_DataStream;
  SwigClassDataStream.trackObjects = 0;
  
  SwigClassMemoryDataStream.klass = rb_define_class_under(mOgre, "MemoryDataStream", ((swig_class *) SWIGTYPE_p_Ogre__DataStream->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MemoryDataStream, (void *) &SwigClassMemoryDataStream);
  rb_define_alloc_func(SwigClassMemoryDataStream.klass, _wrap_MemoryDataStream_allocate);
  rb_define_method(SwigClassMemoryDataStream.klass, "initialize", VALUEFUNC(_wrap_new_MemoryDataStream), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "getPtr", VALUEFUNC(_wrap_MemoryDataStream_getPtr), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "getCurrentPtr", VALUEFUNC(_wrap_MemoryDataStream_getCurrentPtr), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "read", VALUEFUNC(_wrap_MemoryDataStream_read), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "write", VALUEFUNC(_wrap_MemoryDataStream_write), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "readLine", VALUEFUNC(_wrap_MemoryDataStream_readLine), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "skipLine", VALUEFUNC(_wrap_MemoryDataStream_skipLine), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "skip", VALUEFUNC(_wrap_MemoryDataStream_skip), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "seek", VALUEFUNC(_wrap_MemoryDataStream_seek), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "tell", VALUEFUNC(_wrap_MemoryDataStream_tell), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "eof", VALUEFUNC(_wrap_MemoryDataStream_eof), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "close", VALUEFUNC(_wrap_MemoryDataStream_close), -1);
  rb_define_method(SwigClassMemoryDataStream.klass, "setFreeOnClose", VALUEFUNC(_wrap_MemoryDataStream_setFreeOnClose), -1);
  SwigClassMemoryDataStream.mark = 0;
  SwigClassMemoryDataStream.destroy = (void (*)(void *)) free_Ogre_MemoryDataStream;
  SwigClassMemoryDataStream.trackObjects = 0;
  
  SwigClassFileStreamDataStream.klass = rb_define_class_under(mOgre, "FileStreamDataStream", ((swig_class *) SWIGTYPE_p_Ogre__DataStream->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FileStreamDataStream, (void *) &SwigClassFileStreamDataStream);
  rb_define_alloc_func(SwigClassFileStreamDataStream.klass, _wrap_FileStreamDataStream_allocate);
  rb_define_method(SwigClassFileStreamDataStream.klass, "initialize", VALUEFUNC(_wrap_new_FileStreamDataStream), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "read", VALUEFUNC(_wrap_FileStreamDataStream_read), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "write", VALUEFUNC(_wrap_FileStreamDataStream_write), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "readLine", VALUEFUNC(_wrap_FileStreamDataStream_readLine), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "skip", VALUEFUNC(_wrap_FileStreamDataStream_skip), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "seek", VALUEFUNC(_wrap_FileStreamDataStream_seek), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "tell", VALUEFUNC(_wrap_FileStreamDataStream_tell), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "eof", VALUEFUNC(_wrap_FileStreamDataStream_eof), -1);
  rb_define_method(SwigClassFileStreamDataStream.klass, "close", VALUEFUNC(_wrap_FileStreamDataStream_close), -1);
  SwigClassFileStreamDataStream.mark = 0;
  SwigClassFileStreamDataStream.destroy = (void (*)(void *)) free_Ogre_FileStreamDataStream;
  SwigClassFileStreamDataStream.trackObjects = 0;
  
  SwigClassFileHandleDataStream.klass = rb_define_class_under(mOgre, "FileHandleDataStream", ((swig_class *) SWIGTYPE_p_Ogre__DataStream->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FileHandleDataStream, (void *) &SwigClassFileHandleDataStream);
  rb_define_alloc_func(SwigClassFileHandleDataStream.klass, _wrap_FileHandleDataStream_allocate);
  rb_define_method(SwigClassFileHandleDataStream.klass, "initialize", VALUEFUNC(_wrap_new_FileHandleDataStream), -1);
  rb_define_method(SwigClassFileHandleDataStream.klass, "read", VALUEFUNC(_wrap_FileHandleDataStream_read), -1);
  rb_define_method(SwigClassFileHandleDataStream.klass, "write", VALUEFUNC(_wrap_FileHandleDataStream_write), -1);
  rb_define_method(SwigClassFileHandleDataStream.klass, "skip", VALUEFUNC(_wrap_FileHandleDataStream_skip), -1);
  rb_define_method(SwigClassFileHandleDataStream.klass, "seek", VALUEFUNC(_wrap_FileHandleDataStream_seek), -1);
  rb_define_method(SwigClassFileHandleDataStream.klass, "tell", VALUEFUNC(_wrap_FileHandleDataStream_tell), -1);
  rb_define_method(SwigClassFileHandleDataStream.klass, "eof", VALUEFUNC(_wrap_FileHandleDataStream_eof), -1);
  rb_define_method(SwigClassFileHandleDataStream.klass, "close", VALUEFUNC(_wrap_FileHandleDataStream_close), -1);
  SwigClassFileHandleDataStream.mark = 0;
  SwigClassFileHandleDataStream.destroy = (void (*)(void *)) free_Ogre_FileHandleDataStream;
  SwigClassFileHandleDataStream.trackObjects = 0;
  
  SwigClassFileInfo.klass = rb_define_class_under(mOgre, "FileInfo", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FileInfo, (void *) &SwigClassFileInfo);
  rb_define_alloc_func(SwigClassFileInfo.klass, _wrap_FileInfo_allocate);
  rb_define_method(SwigClassFileInfo.klass, "initialize", VALUEFUNC(_wrap_new_FileInfo), -1);
  rb_define_method(SwigClassFileInfo.klass, "archive=", VALUEFUNC(_wrap_FileInfo_archive_set), -1);
  rb_define_method(SwigClassFileInfo.klass, "archive", VALUEFUNC(_wrap_FileInfo_archive_get), -1);
  rb_define_method(SwigClassFileInfo.klass, "filename=", VALUEFUNC(_wrap_FileInfo_filename_set), -1);
  rb_define_method(SwigClassFileInfo.klass, "filename", VALUEFUNC(_wrap_FileInfo_filename_get), -1);
  rb_define_method(SwigClassFileInfo.klass, "path=", VALUEFUNC(_wrap_FileInfo_path_set), -1);
  rb_define_method(SwigClassFileInfo.klass, "path", VALUEFUNC(_wrap_FileInfo_path_get), -1);
  rb_define_method(SwigClassFileInfo.klass, "basename=", VALUEFUNC(_wrap_FileInfo_basename_set), -1);
  rb_define_method(SwigClassFileInfo.klass, "basename", VALUEFUNC(_wrap_FileInfo_basename_get), -1);
  rb_define_method(SwigClassFileInfo.klass, "compressedSize=", VALUEFUNC(_wrap_FileInfo_compressedSize_set), -1);
  rb_define_method(SwigClassFileInfo.klass, "compressedSize", VALUEFUNC(_wrap_FileInfo_compressedSize_get), -1);
  rb_define_method(SwigClassFileInfo.klass, "uncompressedSize=", VALUEFUNC(_wrap_FileInfo_uncompressedSize_set), -1);
  rb_define_method(SwigClassFileInfo.klass, "uncompressedSize", VALUEFUNC(_wrap_FileInfo_uncompressedSize_get), -1);
  SwigClassFileInfo.mark = 0;
  SwigClassFileInfo.destroy = (void (*)(void *)) free_Ogre_FileInfo;
  SwigClassFileInfo.trackObjects = 0;
  
  SwigClassArchive.klass = rb_define_class_under(mOgre, "Archive", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Archive, (void *) &SwigClassArchive);
  rb_undef_alloc_func(SwigClassArchive.klass);
  rb_define_method(SwigClassArchive.klass, "getName", VALUEFUNC(_wrap_Archive_getName), -1);
  rb_define_method(SwigClassArchive.klass, "isCaseSensitive", VALUEFUNC(_wrap_Archive_isCaseSensitive), -1);
  rb_define_method(SwigClassArchive.klass, "load", VALUEFUNC(_wrap_Archive_load), -1);
  rb_define_method(SwigClassArchive.klass, "unload", VALUEFUNC(_wrap_Archive_unload), -1);
  rb_define_method(SwigClassArchive.klass, "isReadOnly", VALUEFUNC(_wrap_Archive_isReadOnly), -1);
  rb_define_method(SwigClassArchive.klass, "open", VALUEFUNC(_wrap_Archive_open), -1);
  rb_define_method(SwigClassArchive.klass, "create", VALUEFUNC(_wrap_Archive_create), -1);
  rb_define_method(SwigClassArchive.klass, "remove", VALUEFUNC(_wrap_Archive_remove), -1);
  rb_define_method(SwigClassArchive.klass, "list", VALUEFUNC(_wrap_Archive_list), -1);
  rb_define_method(SwigClassArchive.klass, "listFileInfo", VALUEFUNC(_wrap_Archive_listFileInfo), -1);
  rb_define_method(SwigClassArchive.klass, "find", VALUEFUNC(_wrap_Archive_find), -1);
  rb_define_method(SwigClassArchive.klass, "exists", VALUEFUNC(_wrap_Archive_exists), -1);
  rb_define_method(SwigClassArchive.klass, "getModifiedTime", VALUEFUNC(_wrap_Archive_getModifiedTime), -1);
  rb_define_method(SwigClassArchive.klass, "findFileInfo", VALUEFUNC(_wrap_Archive_findFileInfo), -1);
  rb_define_method(SwigClassArchive.klass, "getType", VALUEFUNC(_wrap_Archive_getType), -1);
  SwigClassArchive.mark = 0;
  SwigClassArchive.destroy = (void (*)(void *)) free_Ogre_Archive;
  SwigClassArchive.trackObjects = 0;
  
  SwigClassArchiveFactory.klass = rb_define_class_under(mOgre, "ArchiveFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ArchiveFactory, (void *) &SwigClassArchiveFactory);
  rb_undef_alloc_func(SwigClassArchiveFactory.klass);
  SwigClassArchiveFactory.mark = 0;
  SwigClassArchiveFactory.destroy = (void (*)(void *)) free_Ogre_ArchiveFactory;
  SwigClassArchiveFactory.trackObjects = 0;
  rb_define_module_function(mOgre, "FastHash", VALUEFUNC(_wrap_FastHash), -1);
  rb_define_const(mOgre, "CMPF_ALWAYS_FAIL", SWIG_From_int(static_cast< int >(Ogre::CMPF_ALWAYS_FAIL)));
  rb_define_const(mOgre, "CMPF_ALWAYS_PASS", SWIG_From_int(static_cast< int >(Ogre::CMPF_ALWAYS_PASS)));
  rb_define_const(mOgre, "CMPF_LESS", SWIG_From_int(static_cast< int >(Ogre::CMPF_LESS)));
  rb_define_const(mOgre, "CMPF_LESS_EQUAL", SWIG_From_int(static_cast< int >(Ogre::CMPF_LESS_EQUAL)));
  rb_define_const(mOgre, "CMPF_EQUAL", SWIG_From_int(static_cast< int >(Ogre::CMPF_EQUAL)));
  rb_define_const(mOgre, "CMPF_NOT_EQUAL", SWIG_From_int(static_cast< int >(Ogre::CMPF_NOT_EQUAL)));
  rb_define_const(mOgre, "CMPF_GREATER_EQUAL", SWIG_From_int(static_cast< int >(Ogre::CMPF_GREATER_EQUAL)));
  rb_define_const(mOgre, "CMPF_GREATER", SWIG_From_int(static_cast< int >(Ogre::CMPF_GREATER)));
  rb_define_const(mOgre, "TFO_NONE", SWIG_From_int(static_cast< int >(Ogre::TFO_NONE)));
  rb_define_const(mOgre, "TFO_BILINEAR", SWIG_From_int(static_cast< int >(Ogre::TFO_BILINEAR)));
  rb_define_const(mOgre, "TFO_TRILINEAR", SWIG_From_int(static_cast< int >(Ogre::TFO_TRILINEAR)));
  rb_define_const(mOgre, "TFO_ANISOTROPIC", SWIG_From_int(static_cast< int >(Ogre::TFO_ANISOTROPIC)));
  rb_define_const(mOgre, "FT_MIN", SWIG_From_int(static_cast< int >(Ogre::FT_MIN)));
  rb_define_const(mOgre, "FT_MAG", SWIG_From_int(static_cast< int >(Ogre::FT_MAG)));
  rb_define_const(mOgre, "FT_MIP", SWIG_From_int(static_cast< int >(Ogre::FT_MIP)));
  rb_define_const(mOgre, "FO_NONE", SWIG_From_int(static_cast< int >(Ogre::FO_NONE)));
  rb_define_const(mOgre, "FO_POINT", SWIG_From_int(static_cast< int >(Ogre::FO_POINT)));
  rb_define_const(mOgre, "FO_LINEAR", SWIG_From_int(static_cast< int >(Ogre::FO_LINEAR)));
  rb_define_const(mOgre, "FO_ANISOTROPIC", SWIG_From_int(static_cast< int >(Ogre::FO_ANISOTROPIC)));
  rb_define_const(mOgre, "SO_FLAT", SWIG_From_int(static_cast< int >(Ogre::SO_FLAT)));
  rb_define_const(mOgre, "SO_GOURAUD", SWIG_From_int(static_cast< int >(Ogre::SO_GOURAUD)));
  rb_define_const(mOgre, "SO_PHONG", SWIG_From_int(static_cast< int >(Ogre::SO_PHONG)));
  rb_define_const(mOgre, "FOG_NONE", SWIG_From_int(static_cast< int >(Ogre::FOG_NONE)));
  rb_define_const(mOgre, "FOG_EXP", SWIG_From_int(static_cast< int >(Ogre::FOG_EXP)));
  rb_define_const(mOgre, "FOG_EXP2", SWIG_From_int(static_cast< int >(Ogre::FOG_EXP2)));
  rb_define_const(mOgre, "FOG_LINEAR", SWIG_From_int(static_cast< int >(Ogre::FOG_LINEAR)));
  rb_define_const(mOgre, "CULL_NONE", SWIG_From_int(static_cast< int >(Ogre::CULL_NONE)));
  rb_define_const(mOgre, "CULL_CLOCKWISE", SWIG_From_int(static_cast< int >(Ogre::CULL_CLOCKWISE)));
  rb_define_const(mOgre, "CULL_ANTICLOCKWISE", SWIG_From_int(static_cast< int >(Ogre::CULL_ANTICLOCKWISE)));
  rb_define_const(mOgre, "MANUAL_CULL_NONE", SWIG_From_int(static_cast< int >(Ogre::MANUAL_CULL_NONE)));
  rb_define_const(mOgre, "MANUAL_CULL_BACK", SWIG_From_int(static_cast< int >(Ogre::MANUAL_CULL_BACK)));
  rb_define_const(mOgre, "MANUAL_CULL_FRONT", SWIG_From_int(static_cast< int >(Ogre::MANUAL_CULL_FRONT)));
  rb_define_const(mOgre, "WFT_SINE", SWIG_From_int(static_cast< int >(Ogre::WFT_SINE)));
  rb_define_const(mOgre, "WFT_TRIANGLE", SWIG_From_int(static_cast< int >(Ogre::WFT_TRIANGLE)));
  rb_define_const(mOgre, "WFT_SQUARE", SWIG_From_int(static_cast< int >(Ogre::WFT_SQUARE)));
  rb_define_const(mOgre, "WFT_SAWTOOTH", SWIG_From_int(static_cast< int >(Ogre::WFT_SAWTOOTH)));
  rb_define_const(mOgre, "WFT_INVERSE_SAWTOOTH", SWIG_From_int(static_cast< int >(Ogre::WFT_INVERSE_SAWTOOTH)));
  rb_define_const(mOgre, "WFT_PWM", SWIG_From_int(static_cast< int >(Ogre::WFT_PWM)));
  rb_define_const(mOgre, "PM_POINTS", SWIG_From_int(static_cast< int >(Ogre::PM_POINTS)));
  rb_define_const(mOgre, "PM_WIREFRAME", SWIG_From_int(static_cast< int >(Ogre::PM_WIREFRAME)));
  rb_define_const(mOgre, "PM_SOLID", SWIG_From_int(static_cast< int >(Ogre::PM_SOLID)));
  rb_define_const(mOgre, "SHADOWTYPE_NONE", SWIG_From_int(static_cast< int >(Ogre::SHADOWTYPE_NONE)));
  rb_define_const(mOgre, "SHADOWDETAILTYPE_ADDITIVE", SWIG_From_int(static_cast< int >(Ogre::SHADOWDETAILTYPE_ADDITIVE)));
  rb_define_const(mOgre, "SHADOWDETAILTYPE_MODULATIVE", SWIG_From_int(static_cast< int >(Ogre::SHADOWDETAILTYPE_MODULATIVE)));
  rb_define_const(mOgre, "SHADOWDETAILTYPE_INTEGRATED", SWIG_From_int(static_cast< int >(Ogre::SHADOWDETAILTYPE_INTEGRATED)));
  rb_define_const(mOgre, "SHADOWDETAILTYPE_STENCIL", SWIG_From_int(static_cast< int >(Ogre::SHADOWDETAILTYPE_STENCIL)));
  rb_define_const(mOgre, "SHADOWDETAILTYPE_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::SHADOWDETAILTYPE_TEXTURE)));
  rb_define_const(mOgre, "SHADOWTYPE_STENCIL_MODULATIVE", SWIG_From_int(static_cast< int >(Ogre::SHADOWTYPE_STENCIL_MODULATIVE)));
  rb_define_const(mOgre, "SHADOWTYPE_STENCIL_ADDITIVE", SWIG_From_int(static_cast< int >(Ogre::SHADOWTYPE_STENCIL_ADDITIVE)));
  rb_define_const(mOgre, "SHADOWTYPE_TEXTURE_MODULATIVE", SWIG_From_int(static_cast< int >(Ogre::SHADOWTYPE_TEXTURE_MODULATIVE)));
  rb_define_const(mOgre, "SHADOWTYPE_TEXTURE_ADDITIVE", SWIG_From_int(static_cast< int >(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE)));
  rb_define_const(mOgre, "SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED", SWIG_From_int(static_cast< int >(Ogre::SHADOWTYPE_TEXTURE_ADDITIVE_INTEGRATED)));
  rb_define_const(mOgre, "SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED", SWIG_From_int(static_cast< int >(Ogre::SHADOWTYPE_TEXTURE_MODULATIVE_INTEGRATED)));
  rb_define_const(mOgre, "TVC_NONE", SWIG_From_int(static_cast< int >(Ogre::TVC_NONE)));
  rb_define_const(mOgre, "TVC_AMBIENT", SWIG_From_int(static_cast< int >(Ogre::TVC_AMBIENT)));
  rb_define_const(mOgre, "TVC_DIFFUSE", SWIG_From_int(static_cast< int >(Ogre::TVC_DIFFUSE)));
  rb_define_const(mOgre, "TVC_SPECULAR", SWIG_From_int(static_cast< int >(Ogre::TVC_SPECULAR)));
  rb_define_const(mOgre, "TVC_EMISSIVE", SWIG_From_int(static_cast< int >(Ogre::TVC_EMISSIVE)));
  rb_define_const(mOgre, "SM_DIRECTION", SWIG_From_int(static_cast< int >(Ogre::SM_DIRECTION)));
  rb_define_const(mOgre, "SM_DISTANCE", SWIG_From_int(static_cast< int >(Ogre::SM_DISTANCE)));
  rb_define_const(mOgre, "FBT_COLOUR", SWIG_From_int(static_cast< int >(Ogre::FBT_COLOUR)));
  rb_define_const(mOgre, "FBT_DEPTH", SWIG_From_int(static_cast< int >(Ogre::FBT_DEPTH)));
  rb_define_const(mOgre, "FBT_STENCIL", SWIG_From_int(static_cast< int >(Ogre::FBT_STENCIL)));
  rb_define_const(mOgre, "IM_USE16BIT", SWIG_From_int(static_cast< int >(Ogre::IM_USE16BIT)));
  rb_define_const(mOgre, "IM_VTFBESTFIT", SWIG_From_int(static_cast< int >(Ogre::IM_VTFBESTFIT)));
  rb_define_const(mOgre, "IM_VTFBONEMATRIXLOOKUP", SWIG_From_int(static_cast< int >(Ogre::IM_VTFBONEMATRIXLOOKUP)));
  rb_define_const(mOgre, "IM_USEBONEDUALQUATERNIONS", SWIG_From_int(static_cast< int >(Ogre::IM_USEBONEDUALQUATERNIONS)));
  rb_define_const(mOgre, "IM_USEONEWEIGHT", SWIG_From_int(static_cast< int >(Ogre::IM_USEONEWEIGHT)));
  rb_define_const(mOgre, "IM_FORCEONEWEIGHT", SWIG_From_int(static_cast< int >(Ogre::IM_FORCEONEWEIGHT)));
  rb_define_const(mOgre, "IM_USEALL", SWIG_From_int(static_cast< int >(Ogre::IM_USEALL)));
  
  SwigClassBox.klass = rb_define_class_under(mOgre, "Box", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Box, (void *) &SwigClassBox);
  rb_define_alloc_func(SwigClassBox.klass, _wrap_Box_allocate);
  rb_define_method(SwigClassBox.klass, "initialize", VALUEFUNC(_wrap_new_Box), -1);
  rb_define_method(SwigClassBox.klass, "left=", VALUEFUNC(_wrap_Box_left_set), -1);
  rb_define_method(SwigClassBox.klass, "left", VALUEFUNC(_wrap_Box_left_get), -1);
  rb_define_method(SwigClassBox.klass, "top=", VALUEFUNC(_wrap_Box_top_set), -1);
  rb_define_method(SwigClassBox.klass, "top", VALUEFUNC(_wrap_Box_top_get), -1);
  rb_define_method(SwigClassBox.klass, "right=", VALUEFUNC(_wrap_Box_right_set), -1);
  rb_define_method(SwigClassBox.klass, "right", VALUEFUNC(_wrap_Box_right_get), -1);
  rb_define_method(SwigClassBox.klass, "bottom=", VALUEFUNC(_wrap_Box_bottom_set), -1);
  rb_define_method(SwigClassBox.klass, "bottom", VALUEFUNC(_wrap_Box_bottom_get), -1);
  rb_define_method(SwigClassBox.klass, "front=", VALUEFUNC(_wrap_Box_front_set), -1);
  rb_define_method(SwigClassBox.klass, "front", VALUEFUNC(_wrap_Box_front_get), -1);
  rb_define_method(SwigClassBox.klass, "back=", VALUEFUNC(_wrap_Box_back_set), -1);
  rb_define_method(SwigClassBox.klass, "back", VALUEFUNC(_wrap_Box_back_get), -1);
  rb_define_method(SwigClassBox.klass, "contains", VALUEFUNC(_wrap_Box_contains), -1);
  rb_define_method(SwigClassBox.klass, "getWidth", VALUEFUNC(_wrap_Box_getWidth), -1);
  rb_define_method(SwigClassBox.klass, "getHeight", VALUEFUNC(_wrap_Box_getHeight), -1);
  rb_define_method(SwigClassBox.klass, "getDepth", VALUEFUNC(_wrap_Box_getDepth), -1);
  SwigClassBox.mark = 0;
  SwigClassBox.destroy = (void (*)(void *)) free_Ogre_Box;
  SwigClassBox.trackObjects = 0;
  rb_define_module_function(mOgre, "findCommandLineOpts", VALUEFUNC(_wrap_findCommandLineOpts), -1);
  rb_define_const(mOgre, "CLIPPED_NONE", SWIG_From_int(static_cast< int >(Ogre::CLIPPED_NONE)));
  rb_define_const(mOgre, "CLIPPED_SOME", SWIG_From_int(static_cast< int >(Ogre::CLIPPED_SOME)));
  rb_define_const(mOgre, "CLIPPED_ALL", SWIG_From_int(static_cast< int >(Ogre::CLIPPED_ALL)));
  
  SwigClassRenderWindowDescription.klass = rb_define_class_under(mOgre, "RenderWindowDescription", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderWindowDescription, (void *) &SwigClassRenderWindowDescription);
  rb_define_alloc_func(SwigClassRenderWindowDescription.klass, _wrap_RenderWindowDescription_allocate);
  rb_define_method(SwigClassRenderWindowDescription.klass, "initialize", VALUEFUNC(_wrap_new_RenderWindowDescription), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "name=", VALUEFUNC(_wrap_RenderWindowDescription_name_set), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "name", VALUEFUNC(_wrap_RenderWindowDescription_name_get), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "width=", VALUEFUNC(_wrap_RenderWindowDescription_width_set), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "width", VALUEFUNC(_wrap_RenderWindowDescription_width_get), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "height=", VALUEFUNC(_wrap_RenderWindowDescription_height_set), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "height", VALUEFUNC(_wrap_RenderWindowDescription_height_get), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "useFullScreen=", VALUEFUNC(_wrap_RenderWindowDescription_useFullScreen_set), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "useFullScreen", VALUEFUNC(_wrap_RenderWindowDescription_useFullScreen_get), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "miscParams=", VALUEFUNC(_wrap_RenderWindowDescription_miscParams_set), -1);
  rb_define_method(SwigClassRenderWindowDescription.klass, "miscParams", VALUEFUNC(_wrap_RenderWindowDescription_miscParams_get), -1);
  SwigClassRenderWindowDescription.mark = 0;
  SwigClassRenderWindowDescription.destroy = (void (*)(void *)) free_Ogre_RenderWindowDescription;
  SwigClassRenderWindowDescription.trackObjects = 0;
  
  SwigClassNameGenerator.klass = rb_define_class_under(mOgre, "NameGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__NameGenerator, (void *) &SwigClassNameGenerator);
  rb_define_alloc_func(SwigClassNameGenerator.klass, _wrap_NameGenerator_allocate);
  rb_define_method(SwigClassNameGenerator.klass, "initialize", VALUEFUNC(_wrap_new_NameGenerator), -1);
  rb_define_method(SwigClassNameGenerator.klass, "generate", VALUEFUNC(_wrap_NameGenerator_generate), -1);
  rb_define_method(SwigClassNameGenerator.klass, "reset", VALUEFUNC(_wrap_NameGenerator_reset), -1);
  rb_define_method(SwigClassNameGenerator.klass, "setNext", VALUEFUNC(_wrap_NameGenerator_setNext), -1);
  rb_define_method(SwigClassNameGenerator.klass, "getNext", VALUEFUNC(_wrap_NameGenerator_getNext), -1);
  SwigClassNameGenerator.mark = 0;
  SwigClassNameGenerator.destroy = (void (*)(void *)) free_Ogre_NameGenerator;
  SwigClassNameGenerator.trackObjects = 0;
  rb_define_const(mOgre, "PT_BOOL", SWIG_From_int(static_cast< int >(Ogre::PT_BOOL)));
  rb_define_const(mOgre, "PT_REAL", SWIG_From_int(static_cast< int >(Ogre::PT_REAL)));
  rb_define_const(mOgre, "PT_INT", SWIG_From_int(static_cast< int >(Ogre::PT_INT)));
  rb_define_const(mOgre, "PT_UNSIGNED_INT", SWIG_From_int(static_cast< int >(Ogre::PT_UNSIGNED_INT)));
  rb_define_const(mOgre, "PT_SHORT", SWIG_From_int(static_cast< int >(Ogre::PT_SHORT)));
  rb_define_const(mOgre, "PT_UNSIGNED_SHORT", SWIG_From_int(static_cast< int >(Ogre::PT_UNSIGNED_SHORT)));
  rb_define_const(mOgre, "PT_LONG", SWIG_From_int(static_cast< int >(Ogre::PT_LONG)));
  rb_define_const(mOgre, "PT_UNSIGNED_LONG", SWIG_From_int(static_cast< int >(Ogre::PT_UNSIGNED_LONG)));
  rb_define_const(mOgre, "PT_STRING", SWIG_From_int(static_cast< int >(Ogre::PT_STRING)));
  rb_define_const(mOgre, "PT_VECTOR3", SWIG_From_int(static_cast< int >(Ogre::PT_VECTOR3)));
  rb_define_const(mOgre, "PT_MATRIX3", SWIG_From_int(static_cast< int >(Ogre::PT_MATRIX3)));
  rb_define_const(mOgre, "PT_MATRIX4", SWIG_From_int(static_cast< int >(Ogre::PT_MATRIX4)));
  rb_define_const(mOgre, "PT_QUATERNION", SWIG_From_int(static_cast< int >(Ogre::PT_QUATERNION)));
  rb_define_const(mOgre, "PT_COLOURVALUE", SWIG_From_int(static_cast< int >(Ogre::PT_COLOURVALUE)));
  
  SwigClassParameterDef.klass = rb_define_class_under(mOgre, "ParameterDef", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParameterDef, (void *) &SwigClassParameterDef);
  rb_define_alloc_func(SwigClassParameterDef.klass, _wrap_ParameterDef_allocate);
  rb_define_method(SwigClassParameterDef.klass, "initialize", VALUEFUNC(_wrap_new_ParameterDef), -1);
  rb_define_method(SwigClassParameterDef.klass, "name=", VALUEFUNC(_wrap_ParameterDef_name_set), -1);
  rb_define_method(SwigClassParameterDef.klass, "name", VALUEFUNC(_wrap_ParameterDef_name_get), -1);
  rb_define_method(SwigClassParameterDef.klass, "description=", VALUEFUNC(_wrap_ParameterDef_description_set), -1);
  rb_define_method(SwigClassParameterDef.klass, "description", VALUEFUNC(_wrap_ParameterDef_description_get), -1);
  rb_define_method(SwigClassParameterDef.klass, "paramType=", VALUEFUNC(_wrap_ParameterDef_paramType_set), -1);
  rb_define_method(SwigClassParameterDef.klass, "paramType", VALUEFUNC(_wrap_ParameterDef_paramType_get), -1);
  SwigClassParameterDef.mark = 0;
  SwigClassParameterDef.destroy = (void (*)(void *)) free_Ogre_ParameterDef;
  SwigClassParameterDef.trackObjects = 0;
  
  SwigClassParamCommand.klass = rb_define_class_under(mOgre, "ParamCommand", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParamCommand, (void *) &SwigClassParamCommand);
  rb_undef_alloc_func(SwigClassParamCommand.klass);
  rb_define_method(SwigClassParamCommand.klass, "doGet", VALUEFUNC(_wrap_ParamCommand_doGet), -1);
  rb_define_method(SwigClassParamCommand.klass, "doSet", VALUEFUNC(_wrap_ParamCommand_doSet), -1);
  SwigClassParamCommand.mark = 0;
  SwigClassParamCommand.destroy = (void (*)(void *)) free_Ogre_ParamCommand;
  SwigClassParamCommand.trackObjects = 0;
  
  SwigClassParamDictionary.klass = rb_define_class_under(mOgre, "ParamDictionary", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParamDictionary, (void *) &SwigClassParamDictionary);
  rb_define_alloc_func(SwigClassParamDictionary.klass, _wrap_ParamDictionary_allocate);
  rb_define_method(SwigClassParamDictionary.klass, "initialize", VALUEFUNC(_wrap_new_ParamDictionary), -1);
  rb_define_method(SwigClassParamDictionary.klass, "addParameter", VALUEFUNC(_wrap_ParamDictionary_addParameter), -1);
  rb_define_method(SwigClassParamDictionary.klass, "getParameters", VALUEFUNC(_wrap_ParamDictionary_getParameters), -1);
  SwigClassParamDictionary.mark = 0;
  SwigClassParamDictionary.destroy = (void (*)(void *)) free_Ogre_ParamDictionary;
  SwigClassParamDictionary.trackObjects = 0;
  
  SwigClassStringInterface.klass = rb_define_class_under(mOgre, "StringInterface", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__StringInterface, (void *) &SwigClassStringInterface);
  rb_define_alloc_func(SwigClassStringInterface.klass, _wrap_StringInterface_allocate);
  rb_define_method(SwigClassStringInterface.klass, "initialize", VALUEFUNC(_wrap_new_StringInterface), -1);
  rb_define_method(SwigClassStringInterface.klass, "getParamDictionary", VALUEFUNC(_wrap_StringInterface_getParamDictionary), -1);
  rb_define_method(SwigClassStringInterface.klass, "getParameters", VALUEFUNC(_wrap_StringInterface_getParameters), -1);
  rb_define_method(SwigClassStringInterface.klass, "setParameter", VALUEFUNC(_wrap_StringInterface_setParameter), -1);
  rb_define_method(SwigClassStringInterface.klass, "setParameterList", VALUEFUNC(_wrap_StringInterface_setParameterList), -1);
  rb_define_method(SwigClassStringInterface.klass, "getParameter", VALUEFUNC(_wrap_StringInterface_getParameter), -1);
  rb_define_method(SwigClassStringInterface.klass, "copyParametersTo", VALUEFUNC(_wrap_StringInterface_copyParametersTo), -1);
  rb_define_singleton_method(SwigClassStringInterface.klass, "cleanupDictionary", VALUEFUNC(_wrap_StringInterface_cleanupDictionary), -1);
  SwigClassStringInterface.mark = 0;
  SwigClassStringInterface.destroy = (void (*)(void *)) free_Ogre_StringInterface;
  SwigClassStringInterface.trackObjects = 0;
  
  SwigClassResourceSharedPtr.klass = rb_define_class_under(mOgre, "ResourceSharedPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Resource_t, (void *) &SwigClassResourceSharedPtr);
  rb_define_alloc_func(SwigClassResourceSharedPtr.klass, _wrap_ResourceSharedPtr_allocate);
  rb_define_method(SwigClassResourceSharedPtr.klass, "initialize", VALUEFUNC(_wrap_new_ResourceSharedPtr), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "__ref__", VALUEFUNC(_wrap_ResourceSharedPtr___ref__), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "__deref__", VALUEFUNC(_wrap_ResourceSharedPtr___deref__), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "get", VALUEFUNC(_wrap_ResourceSharedPtr_get), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "bind", VALUEFUNC(_wrap_ResourceSharedPtr_bind), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "unique", VALUEFUNC(_wrap_ResourceSharedPtr_unique), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "useCount", VALUEFUNC(_wrap_ResourceSharedPtr_useCount), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "useCountPointer", VALUEFUNC(_wrap_ResourceSharedPtr_useCountPointer), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getPointer", VALUEFUNC(_wrap_ResourceSharedPtr_getPointer), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "freeMethod", VALUEFUNC(_wrap_ResourceSharedPtr_freeMethod), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "isNull", VALUEFUNC(_wrap_ResourceSharedPtr_isNull), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "setNull", VALUEFUNC(_wrap_ResourceSharedPtr_setNull), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "prepare", VALUEFUNC(_wrap_ResourceSharedPtr_prepare), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "load", VALUEFUNC(_wrap_ResourceSharedPtr_load), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "reload", VALUEFUNC(_wrap_ResourceSharedPtr_reload), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "isReloadable", VALUEFUNC(_wrap_ResourceSharedPtr_isReloadable), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "isManuallyLoaded", VALUEFUNC(_wrap_ResourceSharedPtr_isManuallyLoaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "unload", VALUEFUNC(_wrap_ResourceSharedPtr_unload), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getSize", VALUEFUNC(_wrap_ResourceSharedPtr_getSize), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "touch", VALUEFUNC(_wrap_ResourceSharedPtr_touch), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getName", VALUEFUNC(_wrap_ResourceSharedPtr_getName), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getHandle", VALUEFUNC(_wrap_ResourceSharedPtr_getHandle), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "isPrepared", VALUEFUNC(_wrap_ResourceSharedPtr_isPrepared), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "isLoaded", VALUEFUNC(_wrap_ResourceSharedPtr_isLoaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "isLoading", VALUEFUNC(_wrap_ResourceSharedPtr_isLoading), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getLoadingState", VALUEFUNC(_wrap_ResourceSharedPtr_getLoadingState), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "isBackgroundLoaded", VALUEFUNC(_wrap_ResourceSharedPtr_isBackgroundLoaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "setBackgroundLoaded", VALUEFUNC(_wrap_ResourceSharedPtr_setBackgroundLoaded), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "escalateLoading", VALUEFUNC(_wrap_ResourceSharedPtr_escalateLoading), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "addListener", VALUEFUNC(_wrap_ResourceSharedPtr_addListener), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "removeListener", VALUEFUNC(_wrap_ResourceSharedPtr_removeListener), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getGroup", VALUEFUNC(_wrap_ResourceSharedPtr_getGroup), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "changeGroupOwnership", VALUEFUNC(_wrap_ResourceSharedPtr_changeGroupOwnership), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getCreator", VALUEFUNC(_wrap_ResourceSharedPtr_getCreator), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getOrigin", VALUEFUNC(_wrap_ResourceSharedPtr_getOrigin), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_notifyOrigin", VALUEFUNC(_wrap_ResourceSharedPtr__notifyOrigin), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getStateCount", VALUEFUNC(_wrap_ResourceSharedPtr_getStateCount), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_dirtyState", VALUEFUNC(_wrap_ResourceSharedPtr__dirtyState), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_fireLoadingComplete", VALUEFUNC(_wrap_ResourceSharedPtr__fireLoadingComplete), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_firePreparingComplete", VALUEFUNC(_wrap_ResourceSharedPtr__firePreparingComplete), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "_fireUnloadingComplete", VALUEFUNC(_wrap_ResourceSharedPtr__fireUnloadingComplete), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getParamDictionary", VALUEFUNC(_wrap_ResourceSharedPtr_getParamDictionary), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getParameters", VALUEFUNC(_wrap_ResourceSharedPtr_getParameters), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "setParameter", VALUEFUNC(_wrap_ResourceSharedPtr_setParameter), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "setParameterList", VALUEFUNC(_wrap_ResourceSharedPtr_setParameterList), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "getParameter", VALUEFUNC(_wrap_ResourceSharedPtr_getParameter), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "copyParametersTo", VALUEFUNC(_wrap_ResourceSharedPtr_copyParametersTo), -1);
  rb_define_method(SwigClassResourceSharedPtr.klass, "cleanupDictionary", VALUEFUNC(_wrap_ResourceSharedPtr_cleanupDictionary), -1);
  SwigClassResourceSharedPtr.mark = 0;
  SwigClassResourceSharedPtr.destroy = (void (*)(void *)) free_Ogre_SharedPtr_Sl_Ogre_Resource_Sg_;
  SwigClassResourceSharedPtr.trackObjects = 0;
  
  SwigClassResource.klass = rb_define_class_under(mOgre, "Resource", ((swig_class *) SWIGTYPE_p_Ogre__StringInterface->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Resource, (void *) &SwigClassResource);
  rb_undef_alloc_func(SwigClassResource.klass);
  rb_define_const(SwigClassResource.klass, "LOADSTATE_UNLOADED", SWIG_From_int(static_cast< int >(Ogre::Resource::LOADSTATE_UNLOADED)));
  rb_define_const(SwigClassResource.klass, "LOADSTATE_LOADING", SWIG_From_int(static_cast< int >(Ogre::Resource::LOADSTATE_LOADING)));
  rb_define_const(SwigClassResource.klass, "LOADSTATE_LOADED", SWIG_From_int(static_cast< int >(Ogre::Resource::LOADSTATE_LOADED)));
  rb_define_const(SwigClassResource.klass, "LOADSTATE_UNLOADING", SWIG_From_int(static_cast< int >(Ogre::Resource::LOADSTATE_UNLOADING)));
  rb_define_const(SwigClassResource.klass, "LOADSTATE_PREPARED", SWIG_From_int(static_cast< int >(Ogre::Resource::LOADSTATE_PREPARED)));
  rb_define_const(SwigClassResource.klass, "LOADSTATE_PREPARING", SWIG_From_int(static_cast< int >(Ogre::Resource::LOADSTATE_PREPARING)));
  rb_define_method(SwigClassResource.klass, "prepare", VALUEFUNC(_wrap_Resource_prepare), -1);
  rb_define_method(SwigClassResource.klass, "load", VALUEFUNC(_wrap_Resource_load), -1);
  rb_define_method(SwigClassResource.klass, "reload", VALUEFUNC(_wrap_Resource_reload), -1);
  rb_define_method(SwigClassResource.klass, "isReloadable", VALUEFUNC(_wrap_Resource_isReloadable), -1);
  rb_define_method(SwigClassResource.klass, "isManuallyLoaded", VALUEFUNC(_wrap_Resource_isManuallyLoaded), -1);
  rb_define_method(SwigClassResource.klass, "unload", VALUEFUNC(_wrap_Resource_unload), -1);
  rb_define_method(SwigClassResource.klass, "getSize", VALUEFUNC(_wrap_Resource_getSize), -1);
  rb_define_method(SwigClassResource.klass, "touch", VALUEFUNC(_wrap_Resource_touch), -1);
  rb_define_method(SwigClassResource.klass, "getName", VALUEFUNC(_wrap_Resource_getName), -1);
  rb_define_method(SwigClassResource.klass, "getHandle", VALUEFUNC(_wrap_Resource_getHandle), -1);
  rb_define_method(SwigClassResource.klass, "isPrepared", VALUEFUNC(_wrap_Resource_isPrepared), -1);
  rb_define_method(SwigClassResource.klass, "isLoaded", VALUEFUNC(_wrap_Resource_isLoaded), -1);
  rb_define_method(SwigClassResource.klass, "isLoading", VALUEFUNC(_wrap_Resource_isLoading), -1);
  rb_define_method(SwigClassResource.klass, "getLoadingState", VALUEFUNC(_wrap_Resource_getLoadingState), -1);
  rb_define_method(SwigClassResource.klass, "isBackgroundLoaded", VALUEFUNC(_wrap_Resource_isBackgroundLoaded), -1);
  rb_define_method(SwigClassResource.klass, "setBackgroundLoaded", VALUEFUNC(_wrap_Resource_setBackgroundLoaded), -1);
  rb_define_method(SwigClassResource.klass, "escalateLoading", VALUEFUNC(_wrap_Resource_escalateLoading), -1);
  rb_define_method(SwigClassResource.klass, "addListener", VALUEFUNC(_wrap_Resource_addListener), -1);
  rb_define_method(SwigClassResource.klass, "removeListener", VALUEFUNC(_wrap_Resource_removeListener), -1);
  rb_define_method(SwigClassResource.klass, "getGroup", VALUEFUNC(_wrap_Resource_getGroup), -1);
  rb_define_method(SwigClassResource.klass, "changeGroupOwnership", VALUEFUNC(_wrap_Resource_changeGroupOwnership), -1);
  rb_define_method(SwigClassResource.klass, "getCreator", VALUEFUNC(_wrap_Resource_getCreator), -1);
  rb_define_method(SwigClassResource.klass, "getOrigin", VALUEFUNC(_wrap_Resource_getOrigin), -1);
  rb_define_method(SwigClassResource.klass, "_notifyOrigin", VALUEFUNC(_wrap_Resource__notifyOrigin), -1);
  rb_define_method(SwigClassResource.klass, "getStateCount", VALUEFUNC(_wrap_Resource_getStateCount), -1);
  rb_define_method(SwigClassResource.klass, "_dirtyState", VALUEFUNC(_wrap_Resource__dirtyState), -1);
  rb_define_method(SwigClassResource.klass, "_fireLoadingComplete", VALUEFUNC(_wrap_Resource__fireLoadingComplete), -1);
  rb_define_method(SwigClassResource.klass, "_firePreparingComplete", VALUEFUNC(_wrap_Resource__firePreparingComplete), -1);
  rb_define_method(SwigClassResource.klass, "_fireUnloadingComplete", VALUEFUNC(_wrap_Resource__fireUnloadingComplete), -1);
  SwigClassResource.mark = 0;
  SwigClassResource.destroy = (void (*)(void *)) free_Ogre_Resource;
  SwigClassResource.trackObjects = 0;
  
  SwigClassManualResourceLoader.klass = rb_define_class_under(mOgre, "ManualResourceLoader", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ManualResourceLoader, (void *) &SwigClassManualResourceLoader);
  rb_undef_alloc_func(SwigClassManualResourceLoader.klass);
  rb_define_method(SwigClassManualResourceLoader.klass, "prepareResource", VALUEFUNC(_wrap_ManualResourceLoader_prepareResource), -1);
  rb_define_method(SwigClassManualResourceLoader.klass, "loadResource", VALUEFUNC(_wrap_ManualResourceLoader_loadResource), -1);
  SwigClassManualResourceLoader.mark = 0;
  SwigClassManualResourceLoader.destroy = (void (*)(void *)) free_Ogre_ManualResourceLoader;
  SwigClassManualResourceLoader.trackObjects = 0;
  
  SwigClassResourceGroupListener.klass = rb_define_class_under(mOgre, "ResourceGroupListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ResourceGroupListener, (void *) &SwigClassResourceGroupListener);
  rb_undef_alloc_func(SwigClassResourceGroupListener.klass);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceGroupScriptingStarted", VALUEFUNC(_wrap_ResourceGroupListener_resourceGroupScriptingStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "scriptParseStarted", VALUEFUNC(_wrap_ResourceGroupListener_scriptParseStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "scriptParseEnded", VALUEFUNC(_wrap_ResourceGroupListener_scriptParseEnded), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceGroupScriptingEnded", VALUEFUNC(_wrap_ResourceGroupListener_resourceGroupScriptingEnded), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceGroupPrepareStarted", VALUEFUNC(_wrap_ResourceGroupListener_resourceGroupPrepareStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourcePrepareStarted", VALUEFUNC(_wrap_ResourceGroupListener_resourcePrepareStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourcePrepareEnded", VALUEFUNC(_wrap_ResourceGroupListener_resourcePrepareEnded), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "worldGeometryPrepareStageStarted", VALUEFUNC(_wrap_ResourceGroupListener_worldGeometryPrepareStageStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "worldGeometryPrepareStageEnded", VALUEFUNC(_wrap_ResourceGroupListener_worldGeometryPrepareStageEnded), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceGroupPrepareEnded", VALUEFUNC(_wrap_ResourceGroupListener_resourceGroupPrepareEnded), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceGroupLoadStarted", VALUEFUNC(_wrap_ResourceGroupListener_resourceGroupLoadStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceLoadStarted", VALUEFUNC(_wrap_ResourceGroupListener_resourceLoadStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceLoadEnded", VALUEFUNC(_wrap_ResourceGroupListener_resourceLoadEnded), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "worldGeometryStageStarted", VALUEFUNC(_wrap_ResourceGroupListener_worldGeometryStageStarted), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "worldGeometryStageEnded", VALUEFUNC(_wrap_ResourceGroupListener_worldGeometryStageEnded), -1);
  rb_define_method(SwigClassResourceGroupListener.klass, "resourceGroupLoadEnded", VALUEFUNC(_wrap_ResourceGroupListener_resourceGroupLoadEnded), -1);
  SwigClassResourceGroupListener.mark = 0;
  SwigClassResourceGroupListener.destroy = (void (*)(void *)) free_Ogre_ResourceGroupListener;
  SwigClassResourceGroupListener.trackObjects = 0;
  
  SwigClassResourceLoadingListener.klass = rb_define_class_under(mOgre, "ResourceLoadingListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ResourceLoadingListener, (void *) &SwigClassResourceLoadingListener);
  rb_undef_alloc_func(SwigClassResourceLoadingListener.klass);
  rb_define_method(SwigClassResourceLoadingListener.klass, "resourceLoading", VALUEFUNC(_wrap_ResourceLoadingListener_resourceLoading), -1);
  rb_define_method(SwigClassResourceLoadingListener.klass, "resourceStreamOpened", VALUEFUNC(_wrap_ResourceLoadingListener_resourceStreamOpened), -1);
  rb_define_method(SwigClassResourceLoadingListener.klass, "resourceCollision", VALUEFUNC(_wrap_ResourceLoadingListener_resourceCollision), -1);
  SwigClassResourceLoadingListener.mark = 0;
  SwigClassResourceLoadingListener.destroy = (void (*)(void *)) free_Ogre_ResourceLoadingListener;
  SwigClassResourceLoadingListener.trackObjects = 0;
  
  SwigClassResourceGroupManager.klass = rb_define_class_under(mOgre, "ResourceGroupManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ResourceGroupManager, (void *) &SwigClassResourceGroupManager);
  rb_define_alloc_func(SwigClassResourceGroupManager.klass, _wrap_ResourceGroupManager_allocate);
  rb_define_method(SwigClassResourceGroupManager.klass, "initialize", VALUEFUNC(_wrap_new_ResourceGroupManager), -1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "DEFAULT_RESOURCE_GROUP_NAME", VALUEFUNC(_wrap_ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME_get), 0);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "DEFAULT_RESOURCE_GROUP_NAME=", VALUEFUNC(_wrap_ResourceGroupManager_DEFAULT_RESOURCE_GROUP_NAME_set), 1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "INTERNAL_RESOURCE_GROUP_NAME", VALUEFUNC(_wrap_ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME_get), 0);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "INTERNAL_RESOURCE_GROUP_NAME=", VALUEFUNC(_wrap_ResourceGroupManager_INTERNAL_RESOURCE_GROUP_NAME_set), 1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "AUTODETECT_RESOURCE_GROUP_NAME", VALUEFUNC(_wrap_ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME_get), 0);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "AUTODETECT_RESOURCE_GROUP_NAME=", VALUEFUNC(_wrap_ResourceGroupManager_AUTODETECT_RESOURCE_GROUP_NAME_set), 1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS", VALUEFUNC(_wrap_ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS_get), 0);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS=", VALUEFUNC(_wrap_ResourceGroupManager_RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS_set), 1);
  rb_define_method(SwigClassResourceGroupManager.klass, "createResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_createResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "initialiseResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_initialiseResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "initialiseAllResourceGroups", VALUEFUNC(_wrap_ResourceGroupManager_initialiseAllResourceGroups), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "prepareResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_prepareResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "loadResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_loadResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "unloadResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_unloadResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "unloadUnreferencedResourcesInGroup", VALUEFUNC(_wrap_ResourceGroupManager_unloadUnreferencedResourcesInGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "clearResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_clearResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "destroyResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_destroyResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "isResourceGroupInitialised", VALUEFUNC(_wrap_ResourceGroupManager_isResourceGroupInitialised), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "isResourceGroupLoaded", VALUEFUNC(_wrap_ResourceGroupManager_isResourceGroupLoaded), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "resourceGroupExists", VALUEFUNC(_wrap_ResourceGroupManager_resourceGroupExists), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "addResourceLocation", VALUEFUNC(_wrap_ResourceGroupManager_addResourceLocation), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "removeResourceLocation", VALUEFUNC(_wrap_ResourceGroupManager_removeResourceLocation), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "resourceLocationExists", VALUEFUNC(_wrap_ResourceGroupManager_resourceLocationExists), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "declareResource", VALUEFUNC(_wrap_ResourceGroupManager_declareResource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "undeclareResource", VALUEFUNC(_wrap_ResourceGroupManager_undeclareResource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "openResource", VALUEFUNC(_wrap_ResourceGroupManager_openResource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "openResources", VALUEFUNC(_wrap_ResourceGroupManager_openResources), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "listResourceNames", VALUEFUNC(_wrap_ResourceGroupManager_listResourceNames), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "listResourceFileInfo", VALUEFUNC(_wrap_ResourceGroupManager_listResourceFileInfo), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "findResourceNames", VALUEFUNC(_wrap_ResourceGroupManager_findResourceNames), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "resourceExistsInAnyGroup", VALUEFUNC(_wrap_ResourceGroupManager_resourceExistsInAnyGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "findGroupContainingResource", VALUEFUNC(_wrap_ResourceGroupManager_findGroupContainingResource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "findResourceFileInfo", VALUEFUNC(_wrap_ResourceGroupManager_findResourceFileInfo), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "listResourceLocations", VALUEFUNC(_wrap_ResourceGroupManager_listResourceLocations), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "findResourceLocation", VALUEFUNC(_wrap_ResourceGroupManager_findResourceLocation), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "createResource", VALUEFUNC(_wrap_ResourceGroupManager_createResource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "deleteResource", VALUEFUNC(_wrap_ResourceGroupManager_deleteResource), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "deleteMatchingResources", VALUEFUNC(_wrap_ResourceGroupManager_deleteMatchingResources), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "addResourceGroupListener", VALUEFUNC(_wrap_ResourceGroupManager_addResourceGroupListener), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "removeResourceGroupListener", VALUEFUNC(_wrap_ResourceGroupManager_removeResourceGroupListener), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "setWorldResourceGroupName", VALUEFUNC(_wrap_ResourceGroupManager_setWorldResourceGroupName), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "getWorldResourceGroupName", VALUEFUNC(_wrap_ResourceGroupManager_getWorldResourceGroupName), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "linkWorldGeometryToResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_linkWorldGeometryToResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "unlinkWorldGeometryFromResourceGroup", VALUEFUNC(_wrap_ResourceGroupManager_unlinkWorldGeometryFromResourceGroup), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "isResourceGroupInGlobalPool", VALUEFUNC(_wrap_ResourceGroupManager_isResourceGroupInGlobalPool), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "shutdownAll", VALUEFUNC(_wrap_ResourceGroupManager_shutdownAll), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_registerResourceManager", VALUEFUNC(_wrap_ResourceGroupManager__registerResourceManager), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_unregisterResourceManager", VALUEFUNC(_wrap_ResourceGroupManager__unregisterResourceManager), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "getResourceManagerIterator", VALUEFUNC(_wrap_ResourceGroupManager_getResourceManagerIterator), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_registerScriptLoader", VALUEFUNC(_wrap_ResourceGroupManager__registerScriptLoader), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_unregisterScriptLoader", VALUEFUNC(_wrap_ResourceGroupManager__unregisterScriptLoader), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_findScriptLoader", VALUEFUNC(_wrap_ResourceGroupManager__findScriptLoader), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_getResourceManager", VALUEFUNC(_wrap_ResourceGroupManager__getResourceManager), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notifyResourceCreated", VALUEFUNC(_wrap_ResourceGroupManager__notifyResourceCreated), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notifyResourceRemoved", VALUEFUNC(_wrap_ResourceGroupManager__notifyResourceRemoved), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notifyResourceGroupChanged", VALUEFUNC(_wrap_ResourceGroupManager__notifyResourceGroupChanged), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notifyAllResourcesRemoved", VALUEFUNC(_wrap_ResourceGroupManager__notifyAllResourcesRemoved), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notifyWorldGeometryStageStarted", VALUEFUNC(_wrap_ResourceGroupManager__notifyWorldGeometryStageStarted), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "_notifyWorldGeometryStageEnded", VALUEFUNC(_wrap_ResourceGroupManager__notifyWorldGeometryStageEnded), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "getResourceGroups", VALUEFUNC(_wrap_ResourceGroupManager_getResourceGroups), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "getResourceDeclarationList", VALUEFUNC(_wrap_ResourceGroupManager_getResourceDeclarationList), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "getResourceLocationList", VALUEFUNC(_wrap_ResourceGroupManager_getResourceLocationList), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "setLoadingListener", VALUEFUNC(_wrap_ResourceGroupManager_setLoadingListener), -1);
  rb_define_method(SwigClassResourceGroupManager.klass, "getLoadingListener", VALUEFUNC(_wrap_ResourceGroupManager_getLoadingListener), -1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "getSingleton", VALUEFUNC(_wrap_ResourceGroupManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassResourceGroupManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_ResourceGroupManager_getSingletonPtr), -1);
  SwigClassResourceGroupManager.mark = 0;
  SwigClassResourceGroupManager.destroy = (void (*)(void *)) free_Ogre_ResourceGroupManager;
  SwigClassResourceGroupManager.trackObjects = 0;
  
  SwigClassScriptLoader.klass = rb_define_class_under(mOgre, "ScriptLoader", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptLoader, (void *) &SwigClassScriptLoader);
  rb_undef_alloc_func(SwigClassScriptLoader.klass);
  rb_define_method(SwigClassScriptLoader.klass, "getScriptPatterns", VALUEFUNC(_wrap_ScriptLoader_getScriptPatterns), -1);
  rb_define_method(SwigClassScriptLoader.klass, "parseScript", VALUEFUNC(_wrap_ScriptLoader_parseScript), -1);
  rb_define_method(SwigClassScriptLoader.klass, "getLoadingOrder", VALUEFUNC(_wrap_ScriptLoader_getLoadingOrder), -1);
  SwigClassScriptLoader.mark = 0;
  SwigClassScriptLoader.destroy = (void (*)(void *)) free_Ogre_ScriptLoader;
  SwigClassScriptLoader.trackObjects = 0;
  
  SwigClassResourcePool.klass = rb_define_class_under(mOgre, "ResourcePool", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_ResourcePool, (void *) &SwigClassResourcePool);
  rb_define_alloc_func(SwigClassResourcePool.klass, _wrap_ResourcePool_allocate);
  rb_define_method(SwigClassResourcePool.klass, "initialize", VALUEFUNC(_wrap_new_ResourcePool), -1);
  rb_define_method(SwigClassResourcePool.klass, "getName", VALUEFUNC(_wrap_ResourcePool_getName), -1);
  rb_define_method(SwigClassResourcePool.klass, "clear", VALUEFUNC(_wrap_ResourcePool_clear), -1);
  SwigClassResourcePool.mark = 0;
  SwigClassResourcePool.destroy = (void (*)(void *)) free_ResourcePool;
  SwigClassResourcePool.trackObjects = 0;
  
  SwigClassResourceManager.klass = rb_define_class_under(mOgre, "ResourceManager", ((swig_class *) SWIGTYPE_p_Ogre__ScriptLoader->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ResourceManager, (void *) &SwigClassResourceManager);
  rb_undef_alloc_func(SwigClassResourceManager.klass);
  rb_define_method(SwigClassResourceManager.klass, "create", VALUEFUNC(_wrap_ResourceManager_create), -1);
  rb_define_method(SwigClassResourceManager.klass, "createOrRetrieve", VALUEFUNC(_wrap_ResourceManager_createOrRetrieve), -1);
  rb_define_method(SwigClassResourceManager.klass, "setMemoryBudget", VALUEFUNC(_wrap_ResourceManager_setMemoryBudget), -1);
  rb_define_method(SwigClassResourceManager.klass, "getMemoryBudget", VALUEFUNC(_wrap_ResourceManager_getMemoryBudget), -1);
  rb_define_method(SwigClassResourceManager.klass, "getMemoryUsage", VALUEFUNC(_wrap_ResourceManager_getMemoryUsage), -1);
  rb_define_method(SwigClassResourceManager.klass, "unload", VALUEFUNC(_wrap_ResourceManager_unload), -1);
  rb_define_method(SwigClassResourceManager.klass, "unloadAll", VALUEFUNC(_wrap_ResourceManager_unloadAll), -1);
  rb_define_method(SwigClassResourceManager.klass, "reloadAll", VALUEFUNC(_wrap_ResourceManager_reloadAll), -1);
  rb_define_method(SwigClassResourceManager.klass, "unloadUnreferencedResources", VALUEFUNC(_wrap_ResourceManager_unloadUnreferencedResources), -1);
  rb_define_method(SwigClassResourceManager.klass, "reloadUnreferencedResources", VALUEFUNC(_wrap_ResourceManager_reloadUnreferencedResources), -1);
  rb_define_method(SwigClassResourceManager.klass, "remove", VALUEFUNC(_wrap_ResourceManager_remove), -1);
  rb_define_method(SwigClassResourceManager.klass, "removeAll", VALUEFUNC(_wrap_ResourceManager_removeAll), -1);
  rb_define_method(SwigClassResourceManager.klass, "removeUnreferencedResources", VALUEFUNC(_wrap_ResourceManager_removeUnreferencedResources), -1);
  rb_define_method(SwigClassResourceManager.klass, "getByName", VALUEFUNC(_wrap_ResourceManager_getByName), -1);
  rb_define_method(SwigClassResourceManager.klass, "getByHandle", VALUEFUNC(_wrap_ResourceManager_getByHandle), -1);
  rb_define_method(SwigClassResourceManager.klass, "resourceExists", VALUEFUNC(_wrap_ResourceManager_resourceExists), -1);
  rb_define_method(SwigClassResourceManager.klass, "_notifyResourceTouched", VALUEFUNC(_wrap_ResourceManager__notifyResourceTouched), -1);
  rb_define_method(SwigClassResourceManager.klass, "_notifyResourceLoaded", VALUEFUNC(_wrap_ResourceManager__notifyResourceLoaded), -1);
  rb_define_method(SwigClassResourceManager.klass, "_notifyResourceUnloaded", VALUEFUNC(_wrap_ResourceManager__notifyResourceUnloaded), -1);
  rb_define_method(SwigClassResourceManager.klass, "prepare", VALUEFUNC(_wrap_ResourceManager_prepare), -1);
  rb_define_method(SwigClassResourceManager.klass, "load", VALUEFUNC(_wrap_ResourceManager_load), -1);
  rb_define_method(SwigClassResourceManager.klass, "getScriptPatterns", VALUEFUNC(_wrap_ResourceManager_getScriptPatterns), -1);
  rb_define_method(SwigClassResourceManager.klass, "parseScript", VALUEFUNC(_wrap_ResourceManager_parseScript), -1);
  rb_define_method(SwigClassResourceManager.klass, "getLoadingOrder", VALUEFUNC(_wrap_ResourceManager_getLoadingOrder), -1);
  rb_define_method(SwigClassResourceManager.klass, "getResourceType", VALUEFUNC(_wrap_ResourceManager_getResourceType), -1);
  rb_define_method(SwigClassResourceManager.klass, "setVerbose", VALUEFUNC(_wrap_ResourceManager_setVerbose), -1);
  rb_define_method(SwigClassResourceManager.klass, "getVerbose", VALUEFUNC(_wrap_ResourceManager_getVerbose), -1);
  rb_define_method(SwigClassResourceManager.klass, "getResourcePool", VALUEFUNC(_wrap_ResourceManager_getResourcePool), -1);
  rb_define_method(SwigClassResourceManager.klass, "destroyResourcePool", VALUEFUNC(_wrap_ResourceManager_destroyResourcePool), -1);
  rb_define_method(SwigClassResourceManager.klass, "destroyAllResourcePools", VALUEFUNC(_wrap_ResourceManager_destroyAllResourcePools), -1);
  rb_define_method(SwigClassResourceManager.klass, "getResourceIterator", VALUEFUNC(_wrap_ResourceManager_getResourceIterator), -1);
  SwigClassResourceManager.mark = 0;
  SwigClassResourceManager.destroy = (void (*)(void *)) free_Ogre_ResourceManager;
  SwigClassResourceManager.trackObjects = 0;
  
  SwigClassArchiveManager.klass = rb_define_class_under(mOgre, "ArchiveManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ArchiveManager, (void *) &SwigClassArchiveManager);
  rb_define_alloc_func(SwigClassArchiveManager.klass, _wrap_ArchiveManager_allocate);
  rb_define_method(SwigClassArchiveManager.klass, "initialize", VALUEFUNC(_wrap_new_ArchiveManager), -1);
  rb_define_method(SwigClassArchiveManager.klass, "load", VALUEFUNC(_wrap_ArchiveManager_load), -1);
  rb_define_method(SwigClassArchiveManager.klass, "unload", VALUEFUNC(_wrap_ArchiveManager_unload), -1);
  rb_define_method(SwigClassArchiveManager.klass, "getArchiveIterator", VALUEFUNC(_wrap_ArchiveManager_getArchiveIterator), -1);
  rb_define_method(SwigClassArchiveManager.klass, "addArchiveFactory", VALUEFUNC(_wrap_ArchiveManager_addArchiveFactory), -1);
  rb_define_singleton_method(SwigClassArchiveManager.klass, "getSingleton", VALUEFUNC(_wrap_ArchiveManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassArchiveManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_ArchiveManager_getSingletonPtr), -1);
  SwigClassArchiveManager.mark = 0;
  SwigClassArchiveManager.destroy = (void (*)(void *)) free_Ogre_ArchiveManager;
  SwigClassArchiveManager.trackObjects = 0;
  rb_define_const(mOgre, "RENDER_QUEUE_BACKGROUND", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_BACKGROUND)));
  rb_define_const(mOgre, "RENDER_QUEUE_SKIES_EARLY", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_SKIES_EARLY)));
  rb_define_const(mOgre, "RENDER_QUEUE_1", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_1)));
  rb_define_const(mOgre, "RENDER_QUEUE_2", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_2)));
  rb_define_const(mOgre, "RENDER_QUEUE_WORLD_GEOMETRY_1", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_1)));
  rb_define_const(mOgre, "RENDER_QUEUE_3", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_3)));
  rb_define_const(mOgre, "RENDER_QUEUE_4", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_4)));
  rb_define_const(mOgre, "RENDER_QUEUE_MAIN", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_MAIN)));
  rb_define_const(mOgre, "RENDER_QUEUE_6", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_6)));
  rb_define_const(mOgre, "RENDER_QUEUE_7", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_7)));
  rb_define_const(mOgre, "RENDER_QUEUE_WORLD_GEOMETRY_2", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_WORLD_GEOMETRY_2)));
  rb_define_const(mOgre, "RENDER_QUEUE_8", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_8)));
  rb_define_const(mOgre, "RENDER_QUEUE_9", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_9)));
  rb_define_const(mOgre, "RENDER_QUEUE_SKIES_LATE", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_SKIES_LATE)));
  rb_define_const(mOgre, "RENDER_QUEUE_OVERLAY", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_OVERLAY)));
  rb_define_const(mOgre, "RENDER_QUEUE_MAX", SWIG_From_int(static_cast< int >(Ogre::RENDER_QUEUE_MAX)));
  rb_define_const(mOgre, "OGRE_RENDERABLE_DEFAULT_PRIORITY", SWIG_From_int(static_cast< int >(100)));
  
  SwigClassRenderQueue.klass = rb_define_class_under(mOgre, "RenderQueue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderQueue, (void *) &SwigClassRenderQueue);
  rb_define_alloc_func(SwigClassRenderQueue.klass, _wrap_RenderQueue_allocate);
  rb_define_method(SwigClassRenderQueue.klass, "initialize", VALUEFUNC(_wrap_new_RenderQueue), -1);
  rb_define_method(SwigClassRenderQueue.klass, "clear", VALUEFUNC(_wrap_RenderQueue_clear), -1);
  rb_define_method(SwigClassRenderQueue.klass, "getQueueGroup", VALUEFUNC(_wrap_RenderQueue_getQueueGroup), -1);
  rb_define_method(SwigClassRenderQueue.klass, "addRenderable", VALUEFUNC(_wrap_RenderQueue_addRenderable), -1);
  rb_define_method(SwigClassRenderQueue.klass, "getDefaultQueueGroup", VALUEFUNC(_wrap_RenderQueue_getDefaultQueueGroup), -1);
  rb_define_method(SwigClassRenderQueue.klass, "setDefaultRenderablePriority", VALUEFUNC(_wrap_RenderQueue_setDefaultRenderablePriority), -1);
  rb_define_method(SwigClassRenderQueue.klass, "getDefaultRenderablePriority", VALUEFUNC(_wrap_RenderQueue_getDefaultRenderablePriority), -1);
  rb_define_method(SwigClassRenderQueue.klass, "setDefaultQueueGroup", VALUEFUNC(_wrap_RenderQueue_setDefaultQueueGroup), -1);
  rb_define_method(SwigClassRenderQueue.klass, "_getQueueGroupIterator", VALUEFUNC(_wrap_RenderQueue__getQueueGroupIterator), -1);
  rb_define_method(SwigClassRenderQueue.klass, "setSplitPassesByLightingType", VALUEFUNC(_wrap_RenderQueue_setSplitPassesByLightingType), -1);
  rb_define_method(SwigClassRenderQueue.klass, "getSplitPassesByLightingType", VALUEFUNC(_wrap_RenderQueue_getSplitPassesByLightingType), -1);
  rb_define_method(SwigClassRenderQueue.klass, "setSplitNoShadowPasses", VALUEFUNC(_wrap_RenderQueue_setSplitNoShadowPasses), -1);
  rb_define_method(SwigClassRenderQueue.klass, "getSplitNoShadowPasses", VALUEFUNC(_wrap_RenderQueue_getSplitNoShadowPasses), -1);
  rb_define_method(SwigClassRenderQueue.klass, "setShadowCastersCannotBeReceivers", VALUEFUNC(_wrap_RenderQueue_setShadowCastersCannotBeReceivers), -1);
  rb_define_method(SwigClassRenderQueue.klass, "getShadowCastersCannotBeReceivers", VALUEFUNC(_wrap_RenderQueue_getShadowCastersCannotBeReceivers), -1);
  rb_define_method(SwigClassRenderQueue.klass, "setRenderableListener", VALUEFUNC(_wrap_RenderQueue_setRenderableListener), -1);
  rb_define_method(SwigClassRenderQueue.klass, "getRenderableListener", VALUEFUNC(_wrap_RenderQueue_getRenderableListener), -1);
  rb_define_method(SwigClassRenderQueue.klass, "merge", VALUEFUNC(_wrap_RenderQueue_merge), -1);
  rb_define_method(SwigClassRenderQueue.klass, "processVisibleObject", VALUEFUNC(_wrap_RenderQueue_processVisibleObject), -1);
  SwigClassRenderQueue.mark = 0;
  SwigClassRenderQueue.destroy = (void (*)(void *)) free_Ogre_RenderQueue;
  SwigClassRenderQueue.trackObjects = 0;
  
  SwigClassAxisAlignedBox.klass = rb_define_class_under(mOgre, "AxisAlignedBox", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AxisAlignedBox, (void *) &SwigClassAxisAlignedBox);
  rb_define_alloc_func(SwigClassAxisAlignedBox.klass, _wrap_AxisAlignedBox_allocate);
  rb_define_method(SwigClassAxisAlignedBox.klass, "initialize", VALUEFUNC(_wrap_new_AxisAlignedBox), -1);
  rb_define_const(SwigClassAxisAlignedBox.klass, "EXTENT_NULL", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::EXTENT_NULL)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "EXTENT_FINITE", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::EXTENT_FINITE)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "EXTENT_INFINITE", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::EXTENT_INFINITE)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "FAR_LEFT_BOTTOM", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::FAR_LEFT_BOTTOM)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "FAR_LEFT_TOP", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::FAR_LEFT_TOP)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "FAR_RIGHT_TOP", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::FAR_RIGHT_TOP)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "FAR_RIGHT_BOTTOM", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::FAR_RIGHT_BOTTOM)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "NEAR_RIGHT_BOTTOM", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::NEAR_RIGHT_BOTTOM)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "NEAR_LEFT_BOTTOM", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::NEAR_LEFT_BOTTOM)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "NEAR_LEFT_TOP", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::NEAR_LEFT_TOP)));
  rb_define_const(SwigClassAxisAlignedBox.klass, "NEAR_RIGHT_TOP", SWIG_From_int(static_cast< int >(Ogre::AxisAlignedBox::NEAR_RIGHT_TOP)));
  rb_define_method(SwigClassAxisAlignedBox.klass, "getMinimum", VALUEFUNC(_wrap_AxisAlignedBox_getMinimum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "getMaximum", VALUEFUNC(_wrap_AxisAlignedBox_getMaximum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMinimum", VALUEFUNC(_wrap_AxisAlignedBox_setMinimum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMinimumX", VALUEFUNC(_wrap_AxisAlignedBox_setMinimumX), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMinimumY", VALUEFUNC(_wrap_AxisAlignedBox_setMinimumY), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMinimumZ", VALUEFUNC(_wrap_AxisAlignedBox_setMinimumZ), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMaximum", VALUEFUNC(_wrap_AxisAlignedBox_setMaximum), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMaximumX", VALUEFUNC(_wrap_AxisAlignedBox_setMaximumX), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMaximumY", VALUEFUNC(_wrap_AxisAlignedBox_setMaximumY), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setMaximumZ", VALUEFUNC(_wrap_AxisAlignedBox_setMaximumZ), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setExtents", VALUEFUNC(_wrap_AxisAlignedBox_setExtents), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "getAllCorners", VALUEFUNC(_wrap_AxisAlignedBox_getAllCorners), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "getCorner", VALUEFUNC(_wrap_AxisAlignedBox_getCorner), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "merge", VALUEFUNC(_wrap_AxisAlignedBox_merge), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "transform", VALUEFUNC(_wrap_AxisAlignedBox_transform), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "transformAffine", VALUEFUNC(_wrap_AxisAlignedBox_transformAffine), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setNull", VALUEFUNC(_wrap_AxisAlignedBox_setNull), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "isNull", VALUEFUNC(_wrap_AxisAlignedBox_isNull), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "isFinite", VALUEFUNC(_wrap_AxisAlignedBox_isFinite), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "setInfinite", VALUEFUNC(_wrap_AxisAlignedBox_setInfinite), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "isInfinite", VALUEFUNC(_wrap_AxisAlignedBox_isInfinite), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "intersection", VALUEFUNC(_wrap_AxisAlignedBox_intersection), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "volume", VALUEFUNC(_wrap_AxisAlignedBox_volume), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "scale", VALUEFUNC(_wrap_AxisAlignedBox_scale), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "intersects", VALUEFUNC(_wrap_AxisAlignedBox_intersects), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "getCenter", VALUEFUNC(_wrap_AxisAlignedBox_getCenter), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "getSize", VALUEFUNC(_wrap_AxisAlignedBox_getSize), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "getHalfSize", VALUEFUNC(_wrap_AxisAlignedBox_getHalfSize), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "distance", VALUEFUNC(_wrap_AxisAlignedBox_distance), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "contains", VALUEFUNC(_wrap_AxisAlignedBox_contains), -1);
  rb_define_method(SwigClassAxisAlignedBox.klass, "==", VALUEFUNC(_wrap_AxisAlignedBox___eq__), -1);
  rb_define_singleton_method(SwigClassAxisAlignedBox.klass, "BOX_NULL", VALUEFUNC(_wrap_AxisAlignedBox_BOX_NULL_get), 0);
  rb_define_singleton_method(SwigClassAxisAlignedBox.klass, "BOX_INFINITE", VALUEFUNC(_wrap_AxisAlignedBox_BOX_INFINITE_get), 0);
  SwigClassAxisAlignedBox.mark = 0;
  SwigClassAxisAlignedBox.destroy = (void (*)(void *)) free_Ogre_AxisAlignedBox;
  SwigClassAxisAlignedBox.trackObjects = 0;
  
  SwigClassSphere.klass = rb_define_class_under(mOgre, "Sphere", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Sphere, (void *) &SwigClassSphere);
  rb_define_alloc_func(SwigClassSphere.klass, _wrap_Sphere_allocate);
  rb_define_method(SwigClassSphere.klass, "initialize", VALUEFUNC(_wrap_new_Sphere), -1);
  rb_define_method(SwigClassSphere.klass, "getRadius", VALUEFUNC(_wrap_Sphere_getRadius), -1);
  rb_define_method(SwigClassSphere.klass, "setRadius", VALUEFUNC(_wrap_Sphere_setRadius), -1);
  rb_define_method(SwigClassSphere.klass, "getCenter", VALUEFUNC(_wrap_Sphere_getCenter), -1);
  rb_define_method(SwigClassSphere.klass, "setCenter", VALUEFUNC(_wrap_Sphere_setCenter), -1);
  rb_define_method(SwigClassSphere.klass, "intersects", VALUEFUNC(_wrap_Sphere_intersects), -1);
  rb_define_method(SwigClassSphere.klass, "merge", VALUEFUNC(_wrap_Sphere_merge), -1);
  SwigClassSphere.mark = 0;
  SwigClassSphere.destroy = (void (*)(void *)) free_Ogre_Sphere;
  SwigClassSphere.trackObjects = 0;
  
  SwigClassHardwareIndexBuffer.klass = rb_define_class_under(mOgre, "HardwareIndexBuffer", ((swig_class *) SWIGTYPE_p_Ogre__HardwareBuffer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareIndexBuffer, (void *) &SwigClassHardwareIndexBuffer);
  rb_undef_alloc_func(SwigClassHardwareIndexBuffer.klass);
  rb_define_const(SwigClassHardwareIndexBuffer.klass, "IT_16BIT", SWIG_From_int(static_cast< int >(Ogre::HardwareIndexBuffer::IT_16BIT)));
  rb_define_const(SwigClassHardwareIndexBuffer.klass, "IT_32BIT", SWIG_From_int(static_cast< int >(Ogre::HardwareIndexBuffer::IT_32BIT)));
  rb_define_method(SwigClassHardwareIndexBuffer.klass, "getManager", VALUEFUNC(_wrap_HardwareIndexBuffer_getManager), -1);
  rb_define_method(SwigClassHardwareIndexBuffer.klass, "getType", VALUEFUNC(_wrap_HardwareIndexBuffer_getType), -1);
  rb_define_method(SwigClassHardwareIndexBuffer.klass, "getNumIndexes", VALUEFUNC(_wrap_HardwareIndexBuffer_getNumIndexes), -1);
  rb_define_method(SwigClassHardwareIndexBuffer.klass, "getIndexSize", VALUEFUNC(_wrap_HardwareIndexBuffer_getIndexSize), -1);
  SwigClassHardwareIndexBuffer.mark = 0;
  SwigClassHardwareIndexBuffer.destroy = (void (*)(void *)) free_Ogre_HardwareIndexBuffer;
  SwigClassHardwareIndexBuffer.trackObjects = 0;
  
  SwigClassHardwareIndexBufferSharedPtr.klass = rb_define_class_under(mOgre, "HardwareIndexBufferSharedPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareIndexBufferSharedPtr, (void *) &SwigClassHardwareIndexBufferSharedPtr);
  rb_define_alloc_func(SwigClassHardwareIndexBufferSharedPtr.klass, _wrap_HardwareIndexBufferSharedPtr_allocate);
  rb_define_method(SwigClassHardwareIndexBufferSharedPtr.klass, "initialize", VALUEFUNC(_wrap_new_HardwareIndexBufferSharedPtr), -1);
  SwigClassHardwareIndexBufferSharedPtr.mark = 0;
  SwigClassHardwareIndexBufferSharedPtr.destroy = (void (*)(void *)) free_Ogre_HardwareIndexBufferSharedPtr;
  SwigClassHardwareIndexBufferSharedPtr.trackObjects = 0;
  
  SwigClassVertexData.klass = rb_define_class_under(mOgre, "VertexData", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexData, (void *) &SwigClassVertexData);
  rb_define_alloc_func(SwigClassVertexData.klass, _wrap_VertexData_allocate);
  rb_define_method(SwigClassVertexData.klass, "initialize", VALUEFUNC(_wrap_new_VertexData), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexDeclaration=", VALUEFUNC(_wrap_VertexData_vertexDeclaration_set), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexDeclaration", VALUEFUNC(_wrap_VertexData_vertexDeclaration_get), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexBufferBinding=", VALUEFUNC(_wrap_VertexData_vertexBufferBinding_set), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexBufferBinding", VALUEFUNC(_wrap_VertexData_vertexBufferBinding_get), -1);
  rb_define_method(SwigClassVertexData.klass, "mDeleteDclBinding=", VALUEFUNC(_wrap_VertexData_mDeleteDclBinding_set), -1);
  rb_define_method(SwigClassVertexData.klass, "mDeleteDclBinding", VALUEFUNC(_wrap_VertexData_mDeleteDclBinding_get), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexStart=", VALUEFUNC(_wrap_VertexData_vertexStart_set), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexStart", VALUEFUNC(_wrap_VertexData_vertexStart_get), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexCount=", VALUEFUNC(_wrap_VertexData_vertexCount_set), -1);
  rb_define_method(SwigClassVertexData.klass, "vertexCount", VALUEFUNC(_wrap_VertexData_vertexCount_get), -1);
  rb_define_method(SwigClassVertexData.klass, "hwAnimationDataList=", VALUEFUNC(_wrap_VertexData_hwAnimationDataList_set), -1);
  rb_define_method(SwigClassVertexData.klass, "hwAnimationDataList", VALUEFUNC(_wrap_VertexData_hwAnimationDataList_get), -1);
  rb_define_method(SwigClassVertexData.klass, "hwAnimDataItemsUsed=", VALUEFUNC(_wrap_VertexData_hwAnimDataItemsUsed_set), -1);
  rb_define_method(SwigClassVertexData.klass, "hwAnimDataItemsUsed", VALUEFUNC(_wrap_VertexData_hwAnimDataItemsUsed_get), -1);
  rb_define_method(SwigClassVertexData.klass, "clone", VALUEFUNC(_wrap_VertexData_clone), -1);
  rb_define_method(SwigClassVertexData.klass, "prepareForShadowVolume", VALUEFUNC(_wrap_VertexData_prepareForShadowVolume), -1);
  rb_define_method(SwigClassVertexData.klass, "hardwareShadowVolWBuffer=", VALUEFUNC(_wrap_VertexData_hardwareShadowVolWBuffer_set), -1);
  rb_define_method(SwigClassVertexData.klass, "hardwareShadowVolWBuffer", VALUEFUNC(_wrap_VertexData_hardwareShadowVolWBuffer_get), -1);
  rb_define_method(SwigClassVertexData.klass, "reorganiseBuffers", VALUEFUNC(_wrap_VertexData_reorganiseBuffers), -1);
  rb_define_method(SwigClassVertexData.klass, "closeGapsInBindings", VALUEFUNC(_wrap_VertexData_closeGapsInBindings), -1);
  rb_define_method(SwigClassVertexData.klass, "removeUnusedBuffers", VALUEFUNC(_wrap_VertexData_removeUnusedBuffers), -1);
  rb_define_method(SwigClassVertexData.klass, "convertPackedColour", VALUEFUNC(_wrap_VertexData_convertPackedColour), -1);
  rb_define_method(SwigClassVertexData.klass, "allocateHardwareAnimationElements", VALUEFUNC(_wrap_VertexData_allocateHardwareAnimationElements), -1);
  SwigClassVertexData.mark = 0;
  SwigClassVertexData.destroy = (void (*)(void *)) free_Ogre_VertexData;
  SwigClassVertexData.trackObjects = 0;
  
  SwigClassIndexData.klass = rb_define_class_under(mOgre, "IndexData", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__IndexData, (void *) &SwigClassIndexData);
  rb_define_alloc_func(SwigClassIndexData.klass, _wrap_IndexData_allocate);
  rb_define_method(SwigClassIndexData.klass, "initialize", VALUEFUNC(_wrap_new_IndexData), -1);
  rb_define_method(SwigClassIndexData.klass, "indexBuffer=", VALUEFUNC(_wrap_IndexData_indexBuffer_set), -1);
  rb_define_method(SwigClassIndexData.klass, "indexBuffer", VALUEFUNC(_wrap_IndexData_indexBuffer_get), -1);
  rb_define_method(SwigClassIndexData.klass, "indexStart=", VALUEFUNC(_wrap_IndexData_indexStart_set), -1);
  rb_define_method(SwigClassIndexData.klass, "indexStart", VALUEFUNC(_wrap_IndexData_indexStart_get), -1);
  rb_define_method(SwigClassIndexData.klass, "indexCount=", VALUEFUNC(_wrap_IndexData_indexCount_set), -1);
  rb_define_method(SwigClassIndexData.klass, "indexCount", VALUEFUNC(_wrap_IndexData_indexCount_get), -1);
  rb_define_method(SwigClassIndexData.klass, "clone", VALUEFUNC(_wrap_IndexData_clone), -1);
  rb_define_method(SwigClassIndexData.klass, "optimiseVertexCacheTriList", VALUEFUNC(_wrap_IndexData_optimiseVertexCacheTriList), -1);
  SwigClassIndexData.mark = 0;
  SwigClassIndexData.destroy = (void (*)(void *)) free_Ogre_IndexData;
  SwigClassIndexData.trackObjects = 0;
  
  SwigClassVertexCacheProfiler.klass = rb_define_class_under(mOgre, "VertexCacheProfiler", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VertexCacheProfiler, (void *) &SwigClassVertexCacheProfiler);
  rb_define_alloc_func(SwigClassVertexCacheProfiler.klass, _wrap_VertexCacheProfiler_allocate);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "initialize", VALUEFUNC(_wrap_new_VertexCacheProfiler), -1);
  rb_define_const(SwigClassVertexCacheProfiler.klass, "FIFO", SWIG_From_int(static_cast< int >(Ogre::VertexCacheProfiler::FIFO)));
  rb_define_const(SwigClassVertexCacheProfiler.klass, "LRU", SWIG_From_int(static_cast< int >(Ogre::VertexCacheProfiler::LRU)));
  rb_define_method(SwigClassVertexCacheProfiler.klass, "profile", VALUEFUNC(_wrap_VertexCacheProfiler_profile), -1);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "reset", VALUEFUNC(_wrap_VertexCacheProfiler_reset), -1);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "flush", VALUEFUNC(_wrap_VertexCacheProfiler_flush), -1);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "getHits", VALUEFUNC(_wrap_VertexCacheProfiler_getHits), -1);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "getMisses", VALUEFUNC(_wrap_VertexCacheProfiler_getMisses), -1);
  rb_define_method(SwigClassVertexCacheProfiler.klass, "getSize", VALUEFUNC(_wrap_VertexCacheProfiler_getSize), -1);
  SwigClassVertexCacheProfiler.mark = 0;
  SwigClassVertexCacheProfiler.destroy = (void (*)(void *)) free_Ogre_VertexCacheProfiler;
  SwigClassVertexCacheProfiler.trackObjects = 0;
  
  SwigClassRenderOperation.klass = rb_define_class_under(mOgre, "RenderOperation", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderOperation, (void *) &SwigClassRenderOperation);
  rb_define_alloc_func(SwigClassRenderOperation.klass, _wrap_RenderOperation_allocate);
  rb_define_method(SwigClassRenderOperation.klass, "initialize", VALUEFUNC(_wrap_new_RenderOperation), -1);
  rb_define_const(SwigClassRenderOperation.klass, "OT_POINT_LIST", SWIG_From_int(static_cast< int >(Ogre::RenderOperation::OT_POINT_LIST)));
  rb_define_const(SwigClassRenderOperation.klass, "OT_LINE_LIST", SWIG_From_int(static_cast< int >(Ogre::RenderOperation::OT_LINE_LIST)));
  rb_define_const(SwigClassRenderOperation.klass, "OT_LINE_STRIP", SWIG_From_int(static_cast< int >(Ogre::RenderOperation::OT_LINE_STRIP)));
  rb_define_const(SwigClassRenderOperation.klass, "OT_TRIANGLE_LIST", SWIG_From_int(static_cast< int >(Ogre::RenderOperation::OT_TRIANGLE_LIST)));
  rb_define_const(SwigClassRenderOperation.klass, "OT_TRIANGLE_STRIP", SWIG_From_int(static_cast< int >(Ogre::RenderOperation::OT_TRIANGLE_STRIP)));
  rb_define_const(SwigClassRenderOperation.klass, "OT_TRIANGLE_FAN", SWIG_From_int(static_cast< int >(Ogre::RenderOperation::OT_TRIANGLE_FAN)));
  rb_define_method(SwigClassRenderOperation.klass, "vertexData=", VALUEFUNC(_wrap_RenderOperation_vertexData_set), -1);
  rb_define_method(SwigClassRenderOperation.klass, "vertexData", VALUEFUNC(_wrap_RenderOperation_vertexData_get), -1);
  rb_define_method(SwigClassRenderOperation.klass, "operationType=", VALUEFUNC(_wrap_RenderOperation_operationType_set), -1);
  rb_define_method(SwigClassRenderOperation.klass, "operationType", VALUEFUNC(_wrap_RenderOperation_operationType_get), -1);
  rb_define_method(SwigClassRenderOperation.klass, "useIndexes=", VALUEFUNC(_wrap_RenderOperation_useIndexes_set), -1);
  rb_define_method(SwigClassRenderOperation.klass, "useIndexes", VALUEFUNC(_wrap_RenderOperation_useIndexes_get), -1);
  rb_define_method(SwigClassRenderOperation.klass, "indexData=", VALUEFUNC(_wrap_RenderOperation_indexData_set), -1);
  rb_define_method(SwigClassRenderOperation.klass, "indexData", VALUEFUNC(_wrap_RenderOperation_indexData_get), -1);
  rb_define_method(SwigClassRenderOperation.klass, "srcRenderable=", VALUEFUNC(_wrap_RenderOperation_srcRenderable_set), -1);
  rb_define_method(SwigClassRenderOperation.klass, "srcRenderable", VALUEFUNC(_wrap_RenderOperation_srcRenderable_get), -1);
  rb_define_method(SwigClassRenderOperation.klass, "numberOfInstances=", VALUEFUNC(_wrap_RenderOperation_numberOfInstances_set), -1);
  rb_define_method(SwigClassRenderOperation.klass, "numberOfInstances", VALUEFUNC(_wrap_RenderOperation_numberOfInstances_get), -1);
  rb_define_method(SwigClassRenderOperation.klass, "useGlobalInstancingVertexBufferIsAvailable=", VALUEFUNC(_wrap_RenderOperation_useGlobalInstancingVertexBufferIsAvailable_set), -1);
  rb_define_method(SwigClassRenderOperation.klass, "useGlobalInstancingVertexBufferIsAvailable", VALUEFUNC(_wrap_RenderOperation_useGlobalInstancingVertexBufferIsAvailable_get), -1);
  SwigClassRenderOperation.mark = 0;
  SwigClassRenderOperation.destroy = (void (*)(void *)) free_Ogre_RenderOperation;
  SwigClassRenderOperation.trackObjects = 0;
  rb_define_const(mOgre, "LBT_COLOUR", SWIG_From_int(static_cast< int >(Ogre::LBT_COLOUR)));
  rb_define_const(mOgre, "LBT_ALPHA", SWIG_From_int(static_cast< int >(Ogre::LBT_ALPHA)));
  rb_define_const(mOgre, "LBO_REPLACE", SWIG_From_int(static_cast< int >(Ogre::LBO_REPLACE)));
  rb_define_const(mOgre, "LBO_ADD", SWIG_From_int(static_cast< int >(Ogre::LBO_ADD)));
  rb_define_const(mOgre, "LBO_MODULATE", SWIG_From_int(static_cast< int >(Ogre::LBO_MODULATE)));
  rb_define_const(mOgre, "LBO_ALPHA_BLEND", SWIG_From_int(static_cast< int >(Ogre::LBO_ALPHA_BLEND)));
  rb_define_const(mOgre, "LBX_SOURCE1", SWIG_From_int(static_cast< int >(Ogre::LBX_SOURCE1)));
  rb_define_const(mOgre, "LBX_SOURCE2", SWIG_From_int(static_cast< int >(Ogre::LBX_SOURCE2)));
  rb_define_const(mOgre, "LBX_MODULATE", SWIG_From_int(static_cast< int >(Ogre::LBX_MODULATE)));
  rb_define_const(mOgre, "LBX_MODULATE_X2", SWIG_From_int(static_cast< int >(Ogre::LBX_MODULATE_X2)));
  rb_define_const(mOgre, "LBX_MODULATE_X4", SWIG_From_int(static_cast< int >(Ogre::LBX_MODULATE_X4)));
  rb_define_const(mOgre, "LBX_ADD", SWIG_From_int(static_cast< int >(Ogre::LBX_ADD)));
  rb_define_const(mOgre, "LBX_ADD_SIGNED", SWIG_From_int(static_cast< int >(Ogre::LBX_ADD_SIGNED)));
  rb_define_const(mOgre, "LBX_ADD_SMOOTH", SWIG_From_int(static_cast< int >(Ogre::LBX_ADD_SMOOTH)));
  rb_define_const(mOgre, "LBX_SUBTRACT", SWIG_From_int(static_cast< int >(Ogre::LBX_SUBTRACT)));
  rb_define_const(mOgre, "LBX_BLEND_DIFFUSE_ALPHA", SWIG_From_int(static_cast< int >(Ogre::LBX_BLEND_DIFFUSE_ALPHA)));
  rb_define_const(mOgre, "LBX_BLEND_TEXTURE_ALPHA", SWIG_From_int(static_cast< int >(Ogre::LBX_BLEND_TEXTURE_ALPHA)));
  rb_define_const(mOgre, "LBX_BLEND_CURRENT_ALPHA", SWIG_From_int(static_cast< int >(Ogre::LBX_BLEND_CURRENT_ALPHA)));
  rb_define_const(mOgre, "LBX_BLEND_MANUAL", SWIG_From_int(static_cast< int >(Ogre::LBX_BLEND_MANUAL)));
  rb_define_const(mOgre, "LBX_DOTPRODUCT", SWIG_From_int(static_cast< int >(Ogre::LBX_DOTPRODUCT)));
  rb_define_const(mOgre, "LBX_BLEND_DIFFUSE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::LBX_BLEND_DIFFUSE_COLOUR)));
  rb_define_const(mOgre, "LBS_CURRENT", SWIG_From_int(static_cast< int >(Ogre::LBS_CURRENT)));
  rb_define_const(mOgre, "LBS_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::LBS_TEXTURE)));
  rb_define_const(mOgre, "LBS_DIFFUSE", SWIG_From_int(static_cast< int >(Ogre::LBS_DIFFUSE)));
  rb_define_const(mOgre, "LBS_SPECULAR", SWIG_From_int(static_cast< int >(Ogre::LBS_SPECULAR)));
  rb_define_const(mOgre, "LBS_MANUAL", SWIG_From_int(static_cast< int >(Ogre::LBS_MANUAL)));
  
  SwigClassLayerBlendModeEx.klass = rb_define_class_under(mOgre, "LayerBlendModeEx", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LayerBlendModeEx, (void *) &SwigClassLayerBlendModeEx);
  rb_define_alloc_func(SwigClassLayerBlendModeEx.klass, _wrap_LayerBlendModeEx_allocate);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "initialize", VALUEFUNC(_wrap_new_LayerBlendModeEx), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "blendType=", VALUEFUNC(_wrap_LayerBlendModeEx_blendType_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "blendType", VALUEFUNC(_wrap_LayerBlendModeEx_blendType_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "operation=", VALUEFUNC(_wrap_LayerBlendModeEx_operation_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "operation", VALUEFUNC(_wrap_LayerBlendModeEx_operation_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "source1=", VALUEFUNC(_wrap_LayerBlendModeEx_source1_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "source1", VALUEFUNC(_wrap_LayerBlendModeEx_source1_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "source2=", VALUEFUNC(_wrap_LayerBlendModeEx_source2_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "source2", VALUEFUNC(_wrap_LayerBlendModeEx_source2_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "colourArg1=", VALUEFUNC(_wrap_LayerBlendModeEx_colourArg1_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "colourArg1", VALUEFUNC(_wrap_LayerBlendModeEx_colourArg1_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "colourArg2=", VALUEFUNC(_wrap_LayerBlendModeEx_colourArg2_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "colourArg2", VALUEFUNC(_wrap_LayerBlendModeEx_colourArg2_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "alphaArg1=", VALUEFUNC(_wrap_LayerBlendModeEx_alphaArg1_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "alphaArg1", VALUEFUNC(_wrap_LayerBlendModeEx_alphaArg1_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "alphaArg2=", VALUEFUNC(_wrap_LayerBlendModeEx_alphaArg2_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "alphaArg2", VALUEFUNC(_wrap_LayerBlendModeEx_alphaArg2_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "factor=", VALUEFUNC(_wrap_LayerBlendModeEx_factor_set), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "factor", VALUEFUNC(_wrap_LayerBlendModeEx_factor_get), -1);
  rb_define_method(SwigClassLayerBlendModeEx.klass, "==", VALUEFUNC(_wrap_LayerBlendModeEx___eq__), -1);
  SwigClassLayerBlendModeEx.mark = 0;
  SwigClassLayerBlendModeEx.destroy = (void (*)(void *)) free_Ogre_LayerBlendModeEx;
  SwigClassLayerBlendModeEx.trackObjects = 0;
  rb_define_const(mOgre, "SBT_TRANSPARENT_ALPHA", SWIG_From_int(static_cast< int >(Ogre::SBT_TRANSPARENT_ALPHA)));
  rb_define_const(mOgre, "SBT_TRANSPARENT_COLOUR", SWIG_From_int(static_cast< int >(Ogre::SBT_TRANSPARENT_COLOUR)));
  rb_define_const(mOgre, "SBT_ADD", SWIG_From_int(static_cast< int >(Ogre::SBT_ADD)));
  rb_define_const(mOgre, "SBT_MODULATE", SWIG_From_int(static_cast< int >(Ogre::SBT_MODULATE)));
  rb_define_const(mOgre, "SBT_REPLACE", SWIG_From_int(static_cast< int >(Ogre::SBT_REPLACE)));
  rb_define_const(mOgre, "SBF_ONE", SWIG_From_int(static_cast< int >(Ogre::SBF_ONE)));
  rb_define_const(mOgre, "SBF_ZERO", SWIG_From_int(static_cast< int >(Ogre::SBF_ZERO)));
  rb_define_const(mOgre, "SBF_DEST_COLOUR", SWIG_From_int(static_cast< int >(Ogre::SBF_DEST_COLOUR)));
  rb_define_const(mOgre, "SBF_SOURCE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::SBF_SOURCE_COLOUR)));
  rb_define_const(mOgre, "SBF_ONE_MINUS_DEST_COLOUR", SWIG_From_int(static_cast< int >(Ogre::SBF_ONE_MINUS_DEST_COLOUR)));
  rb_define_const(mOgre, "SBF_ONE_MINUS_SOURCE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::SBF_ONE_MINUS_SOURCE_COLOUR)));
  rb_define_const(mOgre, "SBF_DEST_ALPHA", SWIG_From_int(static_cast< int >(Ogre::SBF_DEST_ALPHA)));
  rb_define_const(mOgre, "SBF_SOURCE_ALPHA", SWIG_From_int(static_cast< int >(Ogre::SBF_SOURCE_ALPHA)));
  rb_define_const(mOgre, "SBF_ONE_MINUS_DEST_ALPHA", SWIG_From_int(static_cast< int >(Ogre::SBF_ONE_MINUS_DEST_ALPHA)));
  rb_define_const(mOgre, "SBF_ONE_MINUS_SOURCE_ALPHA", SWIG_From_int(static_cast< int >(Ogre::SBF_ONE_MINUS_SOURCE_ALPHA)));
  rb_define_const(mOgre, "SBO_ADD", SWIG_From_int(static_cast< int >(Ogre::SBO_ADD)));
  rb_define_const(mOgre, "SBO_SUBTRACT", SWIG_From_int(static_cast< int >(Ogre::SBO_SUBTRACT)));
  rb_define_const(mOgre, "SBO_REVERSE_SUBTRACT", SWIG_From_int(static_cast< int >(Ogre::SBO_REVERSE_SUBTRACT)));
  rb_define_const(mOgre, "SBO_MIN", SWIG_From_int(static_cast< int >(Ogre::SBO_MIN)));
  rb_define_const(mOgre, "SBO_MAX", SWIG_From_int(static_cast< int >(Ogre::SBO_MAX)));
  
  SwigClassMaterialSharedPtr.klass = rb_define_class_under(mOgre, "MaterialSharedPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t, (void *) &SwigClassMaterialSharedPtr);
  rb_define_alloc_func(SwigClassMaterialSharedPtr.klass, _wrap_MaterialSharedPtr_allocate);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "initialize", VALUEFUNC(_wrap_new_MaterialSharedPtr), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "__ref__", VALUEFUNC(_wrap_MaterialSharedPtr___ref__), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "__deref__", VALUEFUNC(_wrap_MaterialSharedPtr___deref__), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "get", VALUEFUNC(_wrap_MaterialSharedPtr_get), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "bind", VALUEFUNC(_wrap_MaterialSharedPtr_bind), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "unique", VALUEFUNC(_wrap_MaterialSharedPtr_unique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "useCount", VALUEFUNC(_wrap_MaterialSharedPtr_useCount), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "useCountPointer", VALUEFUNC(_wrap_MaterialSharedPtr_useCountPointer), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getPointer", VALUEFUNC(_wrap_MaterialSharedPtr_getPointer), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "freeMethod", VALUEFUNC(_wrap_MaterialSharedPtr_freeMethod), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isNull", VALUEFUNC(_wrap_MaterialSharedPtr_isNull), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setNull", VALUEFUNC(_wrap_MaterialSharedPtr_setNull), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isTransparent", VALUEFUNC(_wrap_MaterialSharedPtr_isTransparent), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setReceiveShadows", VALUEFUNC(_wrap_MaterialSharedPtr_setReceiveShadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getReceiveShadows", VALUEFUNC(_wrap_MaterialSharedPtr_getReceiveShadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setTransparencyCastsShadows", VALUEFUNC(_wrap_MaterialSharedPtr_setTransparencyCastsShadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getTransparencyCastsShadows", VALUEFUNC(_wrap_MaterialSharedPtr_getTransparencyCastsShadows), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "createTechnique", VALUEFUNC(_wrap_MaterialSharedPtr_createTechnique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getTechnique", VALUEFUNC(_wrap_MaterialSharedPtr_getTechnique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getNumTechniques", VALUEFUNC(_wrap_MaterialSharedPtr_getNumTechniques), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "removeTechnique", VALUEFUNC(_wrap_MaterialSharedPtr_removeTechnique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "removeAllTechniques", VALUEFUNC(_wrap_MaterialSharedPtr_removeAllTechniques), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getTechniqueIterator", VALUEFUNC(_wrap_MaterialSharedPtr_getTechniqueIterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getSupportedTechniqueIterator", VALUEFUNC(_wrap_MaterialSharedPtr_getSupportedTechniqueIterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getSupportedTechnique", VALUEFUNC(_wrap_MaterialSharedPtr_getSupportedTechnique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getNumSupportedTechniques", VALUEFUNC(_wrap_MaterialSharedPtr_getNumSupportedTechniques), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getUnsupportedTechniquesExplanation", VALUEFUNC(_wrap_MaterialSharedPtr_getUnsupportedTechniquesExplanation), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getNumLodLevels", VALUEFUNC(_wrap_MaterialSharedPtr_getNumLodLevels), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getBestTechnique", VALUEFUNC(_wrap_MaterialSharedPtr_getBestTechnique), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "clone", VALUEFUNC(_wrap_MaterialSharedPtr_clone), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "copyDetailsTo", VALUEFUNC(_wrap_MaterialSharedPtr_copyDetailsTo), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "compile", VALUEFUNC(_wrap_MaterialSharedPtr_compile), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setPointSize", VALUEFUNC(_wrap_MaterialSharedPtr_setPointSize), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setAmbient", VALUEFUNC(_wrap_MaterialSharedPtr_setAmbient), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setDiffuse", VALUEFUNC(_wrap_MaterialSharedPtr_setDiffuse), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setSpecular", VALUEFUNC(_wrap_MaterialSharedPtr_setSpecular), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setShininess", VALUEFUNC(_wrap_MaterialSharedPtr_setShininess), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setSelfIllumination", VALUEFUNC(_wrap_MaterialSharedPtr_setSelfIllumination), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setDepthCheckEnabled", VALUEFUNC(_wrap_MaterialSharedPtr_setDepthCheckEnabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setDepthWriteEnabled", VALUEFUNC(_wrap_MaterialSharedPtr_setDepthWriteEnabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setDepthFunction", VALUEFUNC(_wrap_MaterialSharedPtr_setDepthFunction), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setColourWriteEnabled", VALUEFUNC(_wrap_MaterialSharedPtr_setColourWriteEnabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setCullingMode", VALUEFUNC(_wrap_MaterialSharedPtr_setCullingMode), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setManualCullingMode", VALUEFUNC(_wrap_MaterialSharedPtr_setManualCullingMode), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setLightingEnabled", VALUEFUNC(_wrap_MaterialSharedPtr_setLightingEnabled), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setShadingMode", VALUEFUNC(_wrap_MaterialSharedPtr_setShadingMode), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setFog", VALUEFUNC(_wrap_MaterialSharedPtr_setFog), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setDepthBias", VALUEFUNC(_wrap_MaterialSharedPtr_setDepthBias), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setTextureFiltering", VALUEFUNC(_wrap_MaterialSharedPtr_setTextureFiltering), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setTextureAnisotropy", VALUEFUNC(_wrap_MaterialSharedPtr_setTextureAnisotropy), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setSceneBlending", VALUEFUNC(_wrap_MaterialSharedPtr_setSceneBlending), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setSeparateSceneBlending", VALUEFUNC(_wrap_MaterialSharedPtr_setSeparateSceneBlending), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_notifyNeedsRecompile", VALUEFUNC(_wrap_MaterialSharedPtr__notifyNeedsRecompile), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setLodLevels", VALUEFUNC(_wrap_MaterialSharedPtr_setLodLevels), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getLodValueIterator", VALUEFUNC(_wrap_MaterialSharedPtr_getLodValueIterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getUserLodValueIterator", VALUEFUNC(_wrap_MaterialSharedPtr_getUserLodValueIterator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getLodIndex", VALUEFUNC(_wrap_MaterialSharedPtr_getLodIndex), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getLodStrategy", VALUEFUNC(_wrap_MaterialSharedPtr_getLodStrategy), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setLodStrategy", VALUEFUNC(_wrap_MaterialSharedPtr_setLodStrategy), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "touch", VALUEFUNC(_wrap_MaterialSharedPtr_touch), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "applyTextureAliases", VALUEFUNC(_wrap_MaterialSharedPtr_applyTextureAliases), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getCompilationRequired", VALUEFUNC(_wrap_MaterialSharedPtr_getCompilationRequired), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "cast", VALUEFUNC(_wrap_MaterialSharedPtr_cast), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "prepare", VALUEFUNC(_wrap_MaterialSharedPtr_prepare), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "load", VALUEFUNC(_wrap_MaterialSharedPtr_load), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "reload", VALUEFUNC(_wrap_MaterialSharedPtr_reload), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isReloadable", VALUEFUNC(_wrap_MaterialSharedPtr_isReloadable), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isManuallyLoaded", VALUEFUNC(_wrap_MaterialSharedPtr_isManuallyLoaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "unload", VALUEFUNC(_wrap_MaterialSharedPtr_unload), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getSize", VALUEFUNC(_wrap_MaterialSharedPtr_getSize), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getName", VALUEFUNC(_wrap_MaterialSharedPtr_getName), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getHandle", VALUEFUNC(_wrap_MaterialSharedPtr_getHandle), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isPrepared", VALUEFUNC(_wrap_MaterialSharedPtr_isPrepared), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isLoaded", VALUEFUNC(_wrap_MaterialSharedPtr_isLoaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isLoading", VALUEFUNC(_wrap_MaterialSharedPtr_isLoading), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getLoadingState", VALUEFUNC(_wrap_MaterialSharedPtr_getLoadingState), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "isBackgroundLoaded", VALUEFUNC(_wrap_MaterialSharedPtr_isBackgroundLoaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setBackgroundLoaded", VALUEFUNC(_wrap_MaterialSharedPtr_setBackgroundLoaded), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "escalateLoading", VALUEFUNC(_wrap_MaterialSharedPtr_escalateLoading), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "addListener", VALUEFUNC(_wrap_MaterialSharedPtr_addListener), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "removeListener", VALUEFUNC(_wrap_MaterialSharedPtr_removeListener), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getGroup", VALUEFUNC(_wrap_MaterialSharedPtr_getGroup), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "changeGroupOwnership", VALUEFUNC(_wrap_MaterialSharedPtr_changeGroupOwnership), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getCreator", VALUEFUNC(_wrap_MaterialSharedPtr_getCreator), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getOrigin", VALUEFUNC(_wrap_MaterialSharedPtr_getOrigin), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_notifyOrigin", VALUEFUNC(_wrap_MaterialSharedPtr__notifyOrigin), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getStateCount", VALUEFUNC(_wrap_MaterialSharedPtr_getStateCount), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_dirtyState", VALUEFUNC(_wrap_MaterialSharedPtr__dirtyState), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_fireLoadingComplete", VALUEFUNC(_wrap_MaterialSharedPtr__fireLoadingComplete), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_firePreparingComplete", VALUEFUNC(_wrap_MaterialSharedPtr__firePreparingComplete), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "_fireUnloadingComplete", VALUEFUNC(_wrap_MaterialSharedPtr__fireUnloadingComplete), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getParamDictionary", VALUEFUNC(_wrap_MaterialSharedPtr_getParamDictionary), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getParameters", VALUEFUNC(_wrap_MaterialSharedPtr_getParameters), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setParameter", VALUEFUNC(_wrap_MaterialSharedPtr_setParameter), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "setParameterList", VALUEFUNC(_wrap_MaterialSharedPtr_setParameterList), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "getParameter", VALUEFUNC(_wrap_MaterialSharedPtr_getParameter), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "copyParametersTo", VALUEFUNC(_wrap_MaterialSharedPtr_copyParametersTo), -1);
  rb_define_method(SwigClassMaterialSharedPtr.klass, "cleanupDictionary", VALUEFUNC(_wrap_MaterialSharedPtr_cleanupDictionary), -1);
  SwigClassMaterialSharedPtr.mark = 0;
  SwigClassMaterialSharedPtr.destroy = (void (*)(void *)) free_Ogre_SharedPtr_Sl_Ogre_Material_Sg_;
  SwigClassMaterialSharedPtr.trackObjects = 0;
  
  SwigClassMaterial.klass = rb_define_class_under(mOgre, "Material", ((swig_class *) SWIGTYPE_p_Ogre__Resource->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Material, (void *) &SwigClassMaterial);
  rb_define_alloc_func(SwigClassMaterial.klass, _wrap_Material_allocate);
  rb_define_method(SwigClassMaterial.klass, "initialize", VALUEFUNC(_wrap_new_Material), -1);
  rb_define_method(SwigClassMaterial.klass, "isTransparent", VALUEFUNC(_wrap_Material_isTransparent), -1);
  rb_define_method(SwigClassMaterial.klass, "setReceiveShadows", VALUEFUNC(_wrap_Material_setReceiveShadows), -1);
  rb_define_method(SwigClassMaterial.klass, "getReceiveShadows", VALUEFUNC(_wrap_Material_getReceiveShadows), -1);
  rb_define_method(SwigClassMaterial.klass, "setTransparencyCastsShadows", VALUEFUNC(_wrap_Material_setTransparencyCastsShadows), -1);
  rb_define_method(SwigClassMaterial.klass, "getTransparencyCastsShadows", VALUEFUNC(_wrap_Material_getTransparencyCastsShadows), -1);
  rb_define_method(SwigClassMaterial.klass, "createTechnique", VALUEFUNC(_wrap_Material_createTechnique), -1);
  rb_define_method(SwigClassMaterial.klass, "getTechnique", VALUEFUNC(_wrap_Material_getTechnique), -1);
  rb_define_method(SwigClassMaterial.klass, "getNumTechniques", VALUEFUNC(_wrap_Material_getNumTechniques), -1);
  rb_define_method(SwigClassMaterial.klass, "removeTechnique", VALUEFUNC(_wrap_Material_removeTechnique), -1);
  rb_define_method(SwigClassMaterial.klass, "removeAllTechniques", VALUEFUNC(_wrap_Material_removeAllTechniques), -1);
  rb_define_method(SwigClassMaterial.klass, "getTechniqueIterator", VALUEFUNC(_wrap_Material_getTechniqueIterator), -1);
  rb_define_method(SwigClassMaterial.klass, "getSupportedTechniqueIterator", VALUEFUNC(_wrap_Material_getSupportedTechniqueIterator), -1);
  rb_define_method(SwigClassMaterial.klass, "getSupportedTechnique", VALUEFUNC(_wrap_Material_getSupportedTechnique), -1);
  rb_define_method(SwigClassMaterial.klass, "getNumSupportedTechniques", VALUEFUNC(_wrap_Material_getNumSupportedTechniques), -1);
  rb_define_method(SwigClassMaterial.klass, "getUnsupportedTechniquesExplanation", VALUEFUNC(_wrap_Material_getUnsupportedTechniquesExplanation), -1);
  rb_define_method(SwigClassMaterial.klass, "getNumLodLevels", VALUEFUNC(_wrap_Material_getNumLodLevels), -1);
  rb_define_method(SwigClassMaterial.klass, "getBestTechnique", VALUEFUNC(_wrap_Material_getBestTechnique), -1);
  rb_define_method(SwigClassMaterial.klass, "clone", VALUEFUNC(_wrap_Material_clone), -1);
  rb_define_method(SwigClassMaterial.klass, "copyDetailsTo", VALUEFUNC(_wrap_Material_copyDetailsTo), -1);
  rb_define_method(SwigClassMaterial.klass, "compile", VALUEFUNC(_wrap_Material_compile), -1);
  rb_define_method(SwigClassMaterial.klass, "setPointSize", VALUEFUNC(_wrap_Material_setPointSize), -1);
  rb_define_method(SwigClassMaterial.klass, "setAmbient", VALUEFUNC(_wrap_Material_setAmbient), -1);
  rb_define_method(SwigClassMaterial.klass, "setDiffuse", VALUEFUNC(_wrap_Material_setDiffuse), -1);
  rb_define_method(SwigClassMaterial.klass, "setSpecular", VALUEFUNC(_wrap_Material_setSpecular), -1);
  rb_define_method(SwigClassMaterial.klass, "setShininess", VALUEFUNC(_wrap_Material_setShininess), -1);
  rb_define_method(SwigClassMaterial.klass, "setSelfIllumination", VALUEFUNC(_wrap_Material_setSelfIllumination), -1);
  rb_define_method(SwigClassMaterial.klass, "setDepthCheckEnabled", VALUEFUNC(_wrap_Material_setDepthCheckEnabled), -1);
  rb_define_method(SwigClassMaterial.klass, "setDepthWriteEnabled", VALUEFUNC(_wrap_Material_setDepthWriteEnabled), -1);
  rb_define_method(SwigClassMaterial.klass, "setDepthFunction", VALUEFUNC(_wrap_Material_setDepthFunction), -1);
  rb_define_method(SwigClassMaterial.klass, "setColourWriteEnabled", VALUEFUNC(_wrap_Material_setColourWriteEnabled), -1);
  rb_define_method(SwigClassMaterial.klass, "setCullingMode", VALUEFUNC(_wrap_Material_setCullingMode), -1);
  rb_define_method(SwigClassMaterial.klass, "setManualCullingMode", VALUEFUNC(_wrap_Material_setManualCullingMode), -1);
  rb_define_method(SwigClassMaterial.klass, "setLightingEnabled", VALUEFUNC(_wrap_Material_setLightingEnabled), -1);
  rb_define_method(SwigClassMaterial.klass, "setShadingMode", VALUEFUNC(_wrap_Material_setShadingMode), -1);
  rb_define_method(SwigClassMaterial.klass, "setFog", VALUEFUNC(_wrap_Material_setFog), -1);
  rb_define_method(SwigClassMaterial.klass, "setDepthBias", VALUEFUNC(_wrap_Material_setDepthBias), -1);
  rb_define_method(SwigClassMaterial.klass, "setTextureFiltering", VALUEFUNC(_wrap_Material_setTextureFiltering), -1);
  rb_define_method(SwigClassMaterial.klass, "setTextureAnisotropy", VALUEFUNC(_wrap_Material_setTextureAnisotropy), -1);
  rb_define_method(SwigClassMaterial.klass, "setSceneBlending", VALUEFUNC(_wrap_Material_setSceneBlending), -1);
  rb_define_method(SwigClassMaterial.klass, "setSeparateSceneBlending", VALUEFUNC(_wrap_Material_setSeparateSceneBlending), -1);
  rb_define_method(SwigClassMaterial.klass, "_notifyNeedsRecompile", VALUEFUNC(_wrap_Material__notifyNeedsRecompile), -1);
  rb_define_method(SwigClassMaterial.klass, "setLodLevels", VALUEFUNC(_wrap_Material_setLodLevels), -1);
  rb_define_method(SwigClassMaterial.klass, "getLodValueIterator", VALUEFUNC(_wrap_Material_getLodValueIterator), -1);
  rb_define_method(SwigClassMaterial.klass, "getUserLodValueIterator", VALUEFUNC(_wrap_Material_getUserLodValueIterator), -1);
  rb_define_method(SwigClassMaterial.klass, "getLodIndex", VALUEFUNC(_wrap_Material_getLodIndex), -1);
  rb_define_method(SwigClassMaterial.klass, "getLodStrategy", VALUEFUNC(_wrap_Material_getLodStrategy), -1);
  rb_define_method(SwigClassMaterial.klass, "setLodStrategy", VALUEFUNC(_wrap_Material_setLodStrategy), -1);
  rb_define_method(SwigClassMaterial.klass, "touch", VALUEFUNC(_wrap_Material_touch), -1);
  rb_define_method(SwigClassMaterial.klass, "applyTextureAliases", VALUEFUNC(_wrap_Material_applyTextureAliases), -1);
  rb_define_method(SwigClassMaterial.klass, "getCompilationRequired", VALUEFUNC(_wrap_Material_getCompilationRequired), -1);
  rb_define_singleton_method(SwigClassMaterial.klass, "cast", VALUEFUNC(_wrap_Material_cast), -1);
  SwigClassMaterial.mark = 0;
  SwigClassMaterial.destroy = (void (*)(void *)) free_Ogre_Material;
  SwigClassMaterial.trackObjects = 0;
  
  SwigClassMaterialPtr.klass = rb_define_class_under(mOgre, "MaterialPtr", ((swig_class *) SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Material_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MaterialPtr, (void *) &SwigClassMaterialPtr);
  rb_define_alloc_func(SwigClassMaterialPtr.klass, _wrap_MaterialPtr_allocate);
  rb_define_method(SwigClassMaterialPtr.klass, "initialize", VALUEFUNC(_wrap_new_MaterialPtr), -1);
  SwigClassMaterialPtr.mark = 0;
  SwigClassMaterialPtr.destroy = (void (*)(void *)) free_Ogre_MaterialPtr;
  SwigClassMaterialPtr.trackObjects = 0;
  
  SwigClassSerializer.klass = rb_define_class_under(mOgre, "Serializer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Serializer, (void *) &SwigClassSerializer);
  rb_define_alloc_func(SwigClassSerializer.klass, _wrap_Serializer_allocate);
  rb_define_method(SwigClassSerializer.klass, "initialize", VALUEFUNC(_wrap_new_Serializer), -1);
  rb_define_const(SwigClassSerializer.klass, "ENDIAN_NATIVE", SWIG_From_int(static_cast< int >(Ogre::Serializer::ENDIAN_NATIVE)));
  rb_define_const(SwigClassSerializer.klass, "ENDIAN_BIG", SWIG_From_int(static_cast< int >(Ogre::Serializer::ENDIAN_BIG)));
  rb_define_const(SwigClassSerializer.klass, "ENDIAN_LITTLE", SWIG_From_int(static_cast< int >(Ogre::Serializer::ENDIAN_LITTLE)));
  SwigClassSerializer.mark = 0;
  SwigClassSerializer.destroy = (void (*)(void *)) free_Ogre_Serializer;
  SwigClassSerializer.trackObjects = 0;
  rb_define_const(mOgre, "GCT_FLOAT1", SWIG_From_int(static_cast< int >(Ogre::GCT_FLOAT1)));
  rb_define_const(mOgre, "GCT_FLOAT2", SWIG_From_int(static_cast< int >(Ogre::GCT_FLOAT2)));
  rb_define_const(mOgre, "GCT_FLOAT3", SWIG_From_int(static_cast< int >(Ogre::GCT_FLOAT3)));
  rb_define_const(mOgre, "GCT_FLOAT4", SWIG_From_int(static_cast< int >(Ogre::GCT_FLOAT4)));
  rb_define_const(mOgre, "GCT_SAMPLER1D", SWIG_From_int(static_cast< int >(Ogre::GCT_SAMPLER1D)));
  rb_define_const(mOgre, "GCT_SAMPLER2D", SWIG_From_int(static_cast< int >(Ogre::GCT_SAMPLER2D)));
  rb_define_const(mOgre, "GCT_SAMPLER3D", SWIG_From_int(static_cast< int >(Ogre::GCT_SAMPLER3D)));
  rb_define_const(mOgre, "GCT_SAMPLERCUBE", SWIG_From_int(static_cast< int >(Ogre::GCT_SAMPLERCUBE)));
  rb_define_const(mOgre, "GCT_SAMPLER1DSHADOW", SWIG_From_int(static_cast< int >(Ogre::GCT_SAMPLER1DSHADOW)));
  rb_define_const(mOgre, "GCT_SAMPLER2DSHADOW", SWIG_From_int(static_cast< int >(Ogre::GCT_SAMPLER2DSHADOW)));
  rb_define_const(mOgre, "GCT_SAMPLER2DARRAY", SWIG_From_int(static_cast< int >(Ogre::GCT_SAMPLER2DARRAY)));
  rb_define_const(mOgre, "GCT_MATRIX_2X2", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_2X2)));
  rb_define_const(mOgre, "GCT_MATRIX_2X3", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_2X3)));
  rb_define_const(mOgre, "GCT_MATRIX_2X4", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_2X4)));
  rb_define_const(mOgre, "GCT_MATRIX_3X2", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_3X2)));
  rb_define_const(mOgre, "GCT_MATRIX_3X3", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_3X3)));
  rb_define_const(mOgre, "GCT_MATRIX_3X4", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_3X4)));
  rb_define_const(mOgre, "GCT_MATRIX_4X2", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_4X2)));
  rb_define_const(mOgre, "GCT_MATRIX_4X3", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_4X3)));
  rb_define_const(mOgre, "GCT_MATRIX_4X4", SWIG_From_int(static_cast< int >(Ogre::GCT_MATRIX_4X4)));
  rb_define_const(mOgre, "GCT_INT1", SWIG_From_int(static_cast< int >(Ogre::GCT_INT1)));
  rb_define_const(mOgre, "GCT_INT2", SWIG_From_int(static_cast< int >(Ogre::GCT_INT2)));
  rb_define_const(mOgre, "GCT_INT3", SWIG_From_int(static_cast< int >(Ogre::GCT_INT3)));
  rb_define_const(mOgre, "GCT_INT4", SWIG_From_int(static_cast< int >(Ogre::GCT_INT4)));
  rb_define_const(mOgre, "GCT_UNKNOWN", SWIG_From_int(static_cast< int >(Ogre::GCT_UNKNOWN)));
  rb_define_const(mOgre, "GPV_GLOBAL", SWIG_From_int(static_cast< int >(Ogre::GPV_GLOBAL)));
  rb_define_const(mOgre, "GPV_PER_OBJECT", SWIG_From_int(static_cast< int >(Ogre::GPV_PER_OBJECT)));
  rb_define_const(mOgre, "GPV_LIGHTS", SWIG_From_int(static_cast< int >(Ogre::GPV_LIGHTS)));
  rb_define_const(mOgre, "GPV_PASS_ITERATION_NUMBER", SWIG_From_int(static_cast< int >(Ogre::GPV_PASS_ITERATION_NUMBER)));
  rb_define_const(mOgre, "GPV_ALL", SWIG_From_int(static_cast< int >(Ogre::GPV_ALL)));
  
  SwigClassGpuConstantDefinition.klass = rb_define_class_under(mOgre, "GpuConstantDefinition", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuConstantDefinition, (void *) &SwigClassGpuConstantDefinition);
  rb_define_alloc_func(SwigClassGpuConstantDefinition.klass, _wrap_GpuConstantDefinition_allocate);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "initialize", VALUEFUNC(_wrap_new_GpuConstantDefinition), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "constType=", VALUEFUNC(_wrap_GpuConstantDefinition_constType_set), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "constType", VALUEFUNC(_wrap_GpuConstantDefinition_constType_get), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "physicalIndex=", VALUEFUNC(_wrap_GpuConstantDefinition_physicalIndex_set), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "physicalIndex", VALUEFUNC(_wrap_GpuConstantDefinition_physicalIndex_get), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "logicalIndex=", VALUEFUNC(_wrap_GpuConstantDefinition_logicalIndex_set), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "logicalIndex", VALUEFUNC(_wrap_GpuConstantDefinition_logicalIndex_get), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "elementSize=", VALUEFUNC(_wrap_GpuConstantDefinition_elementSize_set), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "elementSize", VALUEFUNC(_wrap_GpuConstantDefinition_elementSize_get), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "arraySize=", VALUEFUNC(_wrap_GpuConstantDefinition_arraySize_set), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "arraySize", VALUEFUNC(_wrap_GpuConstantDefinition_arraySize_get), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "variability=", VALUEFUNC(_wrap_GpuConstantDefinition_variability_set), -1);
  rb_define_method(SwigClassGpuConstantDefinition.klass, "variability", VALUEFUNC(_wrap_GpuConstantDefinition_variability_get), -1);
  rb_define_singleton_method(SwigClassGpuConstantDefinition.klass, "isFloat", VALUEFUNC(_wrap_GpuConstantDefinition_isFloat), -1);
  rb_define_singleton_method(SwigClassGpuConstantDefinition.klass, "isSampler", VALUEFUNC(_wrap_GpuConstantDefinition_isSampler), -1);
  rb_define_singleton_method(SwigClassGpuConstantDefinition.klass, "getElementSize", VALUEFUNC(_wrap_GpuConstantDefinition_getElementSize), -1);
  SwigClassGpuConstantDefinition.mark = 0;
  SwigClassGpuConstantDefinition.destroy = (void (*)(void *)) free_Ogre_GpuConstantDefinition;
  SwigClassGpuConstantDefinition.trackObjects = 0;
  
  SwigClassGpuNamedConstants.klass = rb_define_class_under(mOgre, "GpuNamedConstants", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuNamedConstants, (void *) &SwigClassGpuNamedConstants);
  rb_define_alloc_func(SwigClassGpuNamedConstants.klass, _wrap_GpuNamedConstants_allocate);
  rb_define_method(SwigClassGpuNamedConstants.klass, "initialize", VALUEFUNC(_wrap_new_GpuNamedConstants), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "floatBufferSize=", VALUEFUNC(_wrap_GpuNamedConstants_floatBufferSize_set), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "floatBufferSize", VALUEFUNC(_wrap_GpuNamedConstants_floatBufferSize_get), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "intBufferSize=", VALUEFUNC(_wrap_GpuNamedConstants_intBufferSize_set), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "intBufferSize", VALUEFUNC(_wrap_GpuNamedConstants_intBufferSize_get), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "map=", VALUEFUNC(_wrap_GpuNamedConstants_map_set), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "map", VALUEFUNC(_wrap_GpuNamedConstants_map_get), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "generateConstantDefinitionArrayEntries", VALUEFUNC(_wrap_GpuNamedConstants_generateConstantDefinitionArrayEntries), -1);
  rb_define_singleton_method(SwigClassGpuNamedConstants.klass, "getGenerateAllConstantDefinitionArrayEntries", VALUEFUNC(_wrap_GpuNamedConstants_getGenerateAllConstantDefinitionArrayEntries), -1);
  rb_define_singleton_method(SwigClassGpuNamedConstants.klass, "setGenerateAllConstantDefinitionArrayEntries", VALUEFUNC(_wrap_GpuNamedConstants_setGenerateAllConstantDefinitionArrayEntries), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "save", VALUEFUNC(_wrap_GpuNamedConstants_save), -1);
  rb_define_method(SwigClassGpuNamedConstants.klass, "load", VALUEFUNC(_wrap_GpuNamedConstants_load), -1);
  SwigClassGpuNamedConstants.mark = 0;
  SwigClassGpuNamedConstants.destroy = (void (*)(void *)) free_Ogre_GpuNamedConstants;
  SwigClassGpuNamedConstants.trackObjects = 0;
  
  SwigClassGpuNamedConstantsSerializer.klass = rb_define_class_under(mOgre, "GpuNamedConstantsSerializer", ((swig_class *) SWIGTYPE_p_Ogre__Serializer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuNamedConstantsSerializer, (void *) &SwigClassGpuNamedConstantsSerializer);
  rb_define_alloc_func(SwigClassGpuNamedConstantsSerializer.klass, _wrap_GpuNamedConstantsSerializer_allocate);
  rb_define_method(SwigClassGpuNamedConstantsSerializer.klass, "initialize", VALUEFUNC(_wrap_new_GpuNamedConstantsSerializer), -1);
  rb_define_method(SwigClassGpuNamedConstantsSerializer.klass, "exportNamedConstants", VALUEFUNC(_wrap_GpuNamedConstantsSerializer_exportNamedConstants), -1);
  rb_define_method(SwigClassGpuNamedConstantsSerializer.klass, "importNamedConstants", VALUEFUNC(_wrap_GpuNamedConstantsSerializer_importNamedConstants), -1);
  SwigClassGpuNamedConstantsSerializer.mark = 0;
  SwigClassGpuNamedConstantsSerializer.destroy = (void (*)(void *)) free_Ogre_GpuNamedConstantsSerializer;
  SwigClassGpuNamedConstantsSerializer.trackObjects = 0;
  
  SwigClassGpuLogicalIndexUse.klass = rb_define_class_under(mOgre, "GpuLogicalIndexUse", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuLogicalIndexUse, (void *) &SwigClassGpuLogicalIndexUse);
  rb_define_alloc_func(SwigClassGpuLogicalIndexUse.klass, _wrap_GpuLogicalIndexUse_allocate);
  rb_define_method(SwigClassGpuLogicalIndexUse.klass, "initialize", VALUEFUNC(_wrap_new_GpuLogicalIndexUse), -1);
  rb_define_method(SwigClassGpuLogicalIndexUse.klass, "physicalIndex=", VALUEFUNC(_wrap_GpuLogicalIndexUse_physicalIndex_set), -1);
  rb_define_method(SwigClassGpuLogicalIndexUse.klass, "physicalIndex", VALUEFUNC(_wrap_GpuLogicalIndexUse_physicalIndex_get), -1);
  rb_define_method(SwigClassGpuLogicalIndexUse.klass, "currentSize=", VALUEFUNC(_wrap_GpuLogicalIndexUse_currentSize_set), -1);
  rb_define_method(SwigClassGpuLogicalIndexUse.klass, "currentSize", VALUEFUNC(_wrap_GpuLogicalIndexUse_currentSize_get), -1);
  rb_define_method(SwigClassGpuLogicalIndexUse.klass, "variability=", VALUEFUNC(_wrap_GpuLogicalIndexUse_variability_set), -1);
  rb_define_method(SwigClassGpuLogicalIndexUse.klass, "variability", VALUEFUNC(_wrap_GpuLogicalIndexUse_variability_get), -1);
  SwigClassGpuLogicalIndexUse.mark = 0;
  SwigClassGpuLogicalIndexUse.destroy = (void (*)(void *)) free_Ogre_GpuLogicalIndexUse;
  SwigClassGpuLogicalIndexUse.trackObjects = 0;
  
  SwigClassGpuLogicalBufferStruct.klass = rb_define_class_under(mOgre, "GpuLogicalBufferStruct", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuLogicalBufferStruct, (void *) &SwigClassGpuLogicalBufferStruct);
  rb_define_alloc_func(SwigClassGpuLogicalBufferStruct.klass, _wrap_GpuLogicalBufferStruct_allocate);
  rb_define_method(SwigClassGpuLogicalBufferStruct.klass, "initialize", VALUEFUNC(_wrap_new_GpuLogicalBufferStruct), -1);
  rb_define_method(SwigClassGpuLogicalBufferStruct.klass, "map=", VALUEFUNC(_wrap_GpuLogicalBufferStruct_map_set), -1);
  rb_define_method(SwigClassGpuLogicalBufferStruct.klass, "map", VALUEFUNC(_wrap_GpuLogicalBufferStruct_map_get), -1);
  rb_define_method(SwigClassGpuLogicalBufferStruct.klass, "bufferSize=", VALUEFUNC(_wrap_GpuLogicalBufferStruct_bufferSize_set), -1);
  rb_define_method(SwigClassGpuLogicalBufferStruct.klass, "bufferSize", VALUEFUNC(_wrap_GpuLogicalBufferStruct_bufferSize_get), -1);
  SwigClassGpuLogicalBufferStruct.mark = 0;
  SwigClassGpuLogicalBufferStruct.destroy = (void (*)(void *)) free_Ogre_GpuLogicalBufferStruct;
  SwigClassGpuLogicalBufferStruct.trackObjects = 0;
  
  SwigClassGpuSharedParameters.klass = rb_define_class_under(mOgre, "GpuSharedParameters", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuSharedParameters, (void *) &SwigClassGpuSharedParameters);
  rb_define_alloc_func(SwigClassGpuSharedParameters.klass, _wrap_GpuSharedParameters_allocate);
  rb_define_method(SwigClassGpuSharedParameters.klass, "initialize", VALUEFUNC(_wrap_new_GpuSharedParameters), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getName", VALUEFUNC(_wrap_GpuSharedParameters_getName), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "addConstantDefinition", VALUEFUNC(_wrap_GpuSharedParameters_addConstantDefinition), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "removeConstantDefinition", VALUEFUNC(_wrap_GpuSharedParameters_removeConstantDefinition), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "removeAllConstantDefinitions", VALUEFUNC(_wrap_GpuSharedParameters_removeAllConstantDefinitions), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getVersion", VALUEFUNC(_wrap_GpuSharedParameters_getVersion), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "_markDirty", VALUEFUNC(_wrap_GpuSharedParameters__markDirty), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getFrameLastUpdated", VALUEFUNC(_wrap_GpuSharedParameters_getFrameLastUpdated), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getConstantDefinitionIterator", VALUEFUNC(_wrap_GpuSharedParameters_getConstantDefinitionIterator), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getConstantDefinition", VALUEFUNC(_wrap_GpuSharedParameters_getConstantDefinition), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getConstantDefinitions", VALUEFUNC(_wrap_GpuSharedParameters_getConstantDefinitions), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "setNamedConstant", VALUEFUNC(_wrap_GpuSharedParameters_setNamedConstant), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getFloatPointer", VALUEFUNC(_wrap_GpuSharedParameters_getFloatPointer), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "getIntPointer", VALUEFUNC(_wrap_GpuSharedParameters_getIntPointer), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "_setRenderSystemData", VALUEFUNC(_wrap_GpuSharedParameters__setRenderSystemData), -1);
  rb_define_method(SwigClassGpuSharedParameters.klass, "_getRenderSystemData", VALUEFUNC(_wrap_GpuSharedParameters__getRenderSystemData), -1);
  SwigClassGpuSharedParameters.mark = 0;
  SwigClassGpuSharedParameters.destroy = (void (*)(void *)) free_Ogre_GpuSharedParameters;
  SwigClassGpuSharedParameters.trackObjects = 0;
  
  SwigClassGpuSharedParametersUsage.klass = rb_define_class_under(mOgre, "GpuSharedParametersUsage", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuSharedParametersUsage, (void *) &SwigClassGpuSharedParametersUsage);
  rb_define_alloc_func(SwigClassGpuSharedParametersUsage.klass, _wrap_GpuSharedParametersUsage_allocate);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "initialize", VALUEFUNC(_wrap_new_GpuSharedParametersUsage), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "_copySharedParamsToTargetParams", VALUEFUNC(_wrap_GpuSharedParametersUsage__copySharedParamsToTargetParams), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "getName", VALUEFUNC(_wrap_GpuSharedParametersUsage_getName), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "getSharedParams", VALUEFUNC(_wrap_GpuSharedParametersUsage_getSharedParams), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "getTargetParams", VALUEFUNC(_wrap_GpuSharedParametersUsage_getTargetParams), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "_setRenderSystemData", VALUEFUNC(_wrap_GpuSharedParametersUsage__setRenderSystemData), -1);
  rb_define_method(SwigClassGpuSharedParametersUsage.klass, "_getRenderSystemData", VALUEFUNC(_wrap_GpuSharedParametersUsage__getRenderSystemData), -1);
  SwigClassGpuSharedParametersUsage.mark = 0;
  SwigClassGpuSharedParametersUsage.destroy = (void (*)(void *)) free_Ogre_GpuSharedParametersUsage;
  SwigClassGpuSharedParametersUsage.trackObjects = 0;
  
  SwigClassGpuProgramParameters.klass = rb_define_class_under(mOgre, "GpuProgramParameters", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuProgramParameters, (void *) &SwigClassGpuProgramParameters);
  rb_define_alloc_func(SwigClassGpuProgramParameters.klass, _wrap_GpuProgramParameters_allocate);
  rb_define_method(SwigClassGpuProgramParameters.klass, "initialize", VALUEFUNC(_wrap_new_GpuProgramParameters), -1);
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_WORLD_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_WORLD_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_WORLD_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_WORLD_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TRANSPOSE_WORLD_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TRANSPOSE_WORLD_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_TRANSPOSE_WORLD_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_WORLD_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_WORLD_MATRIX_ARRAY_3x4", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_WORLD_MATRIX_ARRAY_3x4)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_WORLD_MATRIX_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_WORLD_MATRIX_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_WORLD_DUALQUATERNION_ARRAY_2x4", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_WORLD_DUALQUATERNION_ARRAY_2x4)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_WORLD_SCALE_SHEAR_MATRIX_ARRAY_3x4)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_VIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_VIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TRANSPOSE_VIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TRANSPOSE_VIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_TRANSPOSE_VIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_VIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_PROJECTION_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_PROJECTION_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_PROJECTION_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_PROJECTION_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TRANSPOSE_PROJECTION_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TRANSPOSE_PROJECTION_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_PROJECTION_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_VIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_VIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TRANSPOSE_VIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TRANSPOSE_VIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_VIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_WORLDVIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_WORLDVIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_WORLDVIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_WORLDVIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TRANSPOSE_WORLDVIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TRANSPOSE_WORLDVIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_WORLDVIEW_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_WORLDVIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_WORLDVIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_WORLDVIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_WORLDVIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TRANSPOSE_WORLDVIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_TRANSPOSE_WORLDVIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_RENDER_TARGET_FLIPPING", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_RENDER_TARGET_FLIPPING)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VERTEX_WINDING", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VERTEX_WINDING)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_FOG_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_FOG_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_FOG_PARAMS", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_FOG_PARAMS)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SURFACE_AMBIENT_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SURFACE_AMBIENT_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SURFACE_DIFFUSE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SURFACE_DIFFUSE_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SURFACE_SPECULAR_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SURFACE_SPECULAR_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SURFACE_EMISSIVE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SURFACE_EMISSIVE_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SURFACE_SHININESS", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SURFACE_SHININESS)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_COUNT", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_COUNT)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_AMBIENT_LIGHT_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_AMBIENT_LIGHT_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIFFUSE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_SPECULAR_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_ATTENUATION", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_ATTENUATION)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SPOTLIGHT_PARAMS", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SPOTLIGHT_PARAMS)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POSITION", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POSITION)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POSITION_OBJECT_SPACE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POSITION_VIEW_SPACE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POSITION_VIEW_SPACE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIRECTION", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIRECTION_OBJECT_SPACE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION_OBJECT_SPACE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIRECTION_VIEW_SPACE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION_VIEW_SPACE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DISTANCE_OBJECT_SPACE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DISTANCE_OBJECT_SPACE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POWER_SCALE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POWER_SCALE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIFFUSE_COLOUR_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_SPECULAR_COLOUR_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIFFUSE_COLOUR_POWER_SCALED_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_SPECULAR_COLOUR_POWER_SCALED_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_ATTENUATION_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_ATTENUATION_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POSITION_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POSITION_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POSITION_OBJECT_SPACE_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POSITION_VIEW_SPACE_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIRECTION_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION_OBJECT_SPACE_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DIRECTION_VIEW_SPACE_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_DISTANCE_OBJECT_SPACE_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_POWER_SCALE_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_POWER_SCALE_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SPOTLIGHT_PARAMS_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SPOTLIGHT_PARAMS_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_DERIVED_AMBIENT_LIGHT_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_DERIVED_AMBIENT_LIGHT_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_DERIVED_SCENE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_DERIVED_SCENE_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_DERIVED_LIGHT_DIFFUSE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_DERIVED_LIGHT_DIFFUSE_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_DERIVED_LIGHT_SPECULAR_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_DERIVED_LIGHT_SPECULAR_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_DERIVED_LIGHT_DIFFUSE_COLOUR_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_DERIVED_LIGHT_SPECULAR_COLOUR_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_NUMBER", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_NUMBER)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_CASTS_SHADOWS", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_CASTS_SHADOWS)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SHADOW_EXTRUSION_DISTANCE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SHADOW_EXTRUSION_DISTANCE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_CAMERA_POSITION", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_CAMERA_POSITION)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_CAMERA_POSITION_OBJECT_SPACE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_CAMERA_POSITION_OBJECT_SPACE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TEXTURE_VIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TEXTURE_VIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TEXTURE_VIEWPROJ_MATRIX_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TEXTURE_WORLDVIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TEXTURE_WORLDVIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TEXTURE_WORLDVIEWPROJ_MATRIX_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SPOTLIGHT_VIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SPOTLIGHT_VIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SPOTLIGHT_VIEWPROJ_MATRIX_ARRAY)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SPOTLIGHT_WORLDVIEWPROJ_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_CUSTOM", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_CUSTOM)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TIME", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TIME)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TIME_0_X", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TIME_0_X)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_COSTIME_0_X", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_COSTIME_0_X)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SINTIME_0_X", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SINTIME_0_X)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TANTIME_0_X", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TANTIME_0_X)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TIME_0_X_PACKED", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TIME_0_X_PACKED)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TIME_0_1", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TIME_0_1)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_COSTIME_0_1", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_COSTIME_0_1)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SINTIME_0_1", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SINTIME_0_1)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TANTIME_0_1", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TANTIME_0_1)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TIME_0_1_PACKED", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TIME_0_1_PACKED)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TIME_0_2PI", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TIME_0_2PI)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_COSTIME_0_2PI", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_COSTIME_0_2PI)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SINTIME_0_2PI", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SINTIME_0_2PI)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TANTIME_0_2PI", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TANTIME_0_2PI)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TIME_0_2PI_PACKED", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TIME_0_2PI_PACKED)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_FRAME_TIME", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_FRAME_TIME)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_FPS", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_FPS)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEWPORT_WIDTH", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEWPORT_WIDTH)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEWPORT_HEIGHT", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEWPORT_HEIGHT)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_VIEWPORT_WIDTH", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_VIEWPORT_WIDTH)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_VIEWPORT_HEIGHT", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_VIEWPORT_HEIGHT)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEWPORT_SIZE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEWPORT_SIZE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEW_DIRECTION", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEW_DIRECTION)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEW_SIDE_VECTOR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEW_SIDE_VECTOR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_VIEW_UP_VECTOR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_VIEW_UP_VECTOR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_FOV", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_FOV)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_NEAR_CLIP_DISTANCE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_NEAR_CLIP_DISTANCE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_FAR_CLIP_DISTANCE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_FAR_CLIP_DISTANCE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_PASS_NUMBER", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_PASS_NUMBER)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_PASS_ITERATION_NUMBER", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_PASS_ITERATION_NUMBER)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_ANIMATION_PARAMETRIC", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_ANIMATION_PARAMETRIC)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TEXEL_OFFSETS", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TEXEL_OFFSETS)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SCENE_DEPTH_RANGE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SCENE_DEPTH_RANGE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SHADOW_SCENE_DEPTH_RANGE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SHADOW_SCENE_DEPTH_RANGE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_SHADOW_COLOUR", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_SHADOW_COLOUR)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TEXTURE_SIZE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TEXTURE_SIZE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_INVERSE_TEXTURE_SIZE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_INVERSE_TEXTURE_SIZE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_PACKED_TEXTURE_SIZE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_PACKED_TEXTURE_SIZE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_TEXTURE_MATRIX", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_TEXTURE_MATRIX)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LOD_CAMERA_POSITION", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LOD_CAMERA_POSITION)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LOD_CAMERA_POSITION_OBJECT_SPACE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LOD_CAMERA_POSITION_OBJECT_SPACE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACT_LIGHT_CUSTOM", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACT_LIGHT_CUSTOM)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACDT_NONE", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACDT_NONE)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACDT_INT", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACDT_INT)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ACDT_REAL", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ACDT_REAL)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ET_INT", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ET_INT)));
  rb_define_const(SwigClassGpuProgramParameters.klass, "ET_REAL", SWIG_From_int(static_cast< int >(Ogre::GpuProgramParameters::ET_REAL)));
  rb_define_method(SwigClassGpuProgramParameters.klass, "_setNamedConstants", VALUEFUNC(_wrap_GpuProgramParameters__setNamedConstants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_setLogicalIndexes", VALUEFUNC(_wrap_GpuProgramParameters__setLogicalIndexes), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "hasNamedParameters", VALUEFUNC(_wrap_GpuProgramParameters_hasNamedParameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "hasLogicalIndexedParameters", VALUEFUNC(_wrap_GpuProgramParameters_hasLogicalIndexedParameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setConstant", VALUEFUNC(_wrap_GpuProgramParameters_setConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_writeRawConstants", VALUEFUNC(_wrap_GpuProgramParameters__writeRawConstants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_readRawConstants", VALUEFUNC(_wrap_GpuProgramParameters__readRawConstants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_writeRawConstant", VALUEFUNC(_wrap_GpuProgramParameters__writeRawConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getConstantDefinitionIterator", VALUEFUNC(_wrap_GpuProgramParameters_getConstantDefinitionIterator), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getConstantDefinition", VALUEFUNC(_wrap_GpuProgramParameters_getConstantDefinition), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getConstantDefinitions", VALUEFUNC(_wrap_GpuProgramParameters_getConstantDefinitions), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getFloatLogicalBufferStruct", VALUEFUNC(_wrap_GpuProgramParameters_getFloatLogicalBufferStruct), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getFloatLogicalIndexForPhysicalIndex", VALUEFUNC(_wrap_GpuProgramParameters_getFloatLogicalIndexForPhysicalIndex), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getIntLogicalIndexForPhysicalIndex", VALUEFUNC(_wrap_GpuProgramParameters_getIntLogicalIndexForPhysicalIndex), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getIntLogicalBufferStruct", VALUEFUNC(_wrap_GpuProgramParameters_getIntLogicalBufferStruct), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getFloatConstantList", VALUEFUNC(_wrap_GpuProgramParameters_getFloatConstantList), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getFloatPointer", VALUEFUNC(_wrap_GpuProgramParameters_getFloatPointer), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getIntConstantList", VALUEFUNC(_wrap_GpuProgramParameters_getIntConstantList), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getIntPointer", VALUEFUNC(_wrap_GpuProgramParameters_getIntPointer), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getAutoConstantList", VALUEFUNC(_wrap_GpuProgramParameters_getAutoConstantList), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setAutoConstantReal", VALUEFUNC(_wrap_GpuProgramParameters_setAutoConstantReal), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setAutoConstant", VALUEFUNC(_wrap_GpuProgramParameters_setAutoConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_setRawAutoConstant", VALUEFUNC(_wrap_GpuProgramParameters__setRawAutoConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_setRawAutoConstantReal", VALUEFUNC(_wrap_GpuProgramParameters__setRawAutoConstantReal), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "clearAutoConstant", VALUEFUNC(_wrap_GpuProgramParameters_clearAutoConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setConstantFromTime", VALUEFUNC(_wrap_GpuProgramParameters_setConstantFromTime), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "clearAutoConstants", VALUEFUNC(_wrap_GpuProgramParameters_clearAutoConstants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getAutoConstantIterator", VALUEFUNC(_wrap_GpuProgramParameters_getAutoConstantIterator), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getAutoConstantCount", VALUEFUNC(_wrap_GpuProgramParameters_getAutoConstantCount), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getAutoConstantEntry", VALUEFUNC(_wrap_GpuProgramParameters_getAutoConstantEntry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "hasAutoConstants", VALUEFUNC(_wrap_GpuProgramParameters_hasAutoConstants), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "findFloatAutoConstantEntry", VALUEFUNC(_wrap_GpuProgramParameters_findFloatAutoConstantEntry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "findIntAutoConstantEntry", VALUEFUNC(_wrap_GpuProgramParameters_findIntAutoConstantEntry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "findAutoConstantEntry", VALUEFUNC(_wrap_GpuProgramParameters_findAutoConstantEntry), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_findRawAutoConstantEntryFloat", VALUEFUNC(_wrap_GpuProgramParameters__findRawAutoConstantEntryFloat), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_findRawAutoConstantEntryInt", VALUEFUNC(_wrap_GpuProgramParameters__findRawAutoConstantEntryInt), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_updateAutoParams", VALUEFUNC(_wrap_GpuProgramParameters__updateAutoParams), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setIgnoreMissingParams", VALUEFUNC(_wrap_GpuProgramParameters_setIgnoreMissingParams), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setNamedConstant", VALUEFUNC(_wrap_GpuProgramParameters_setNamedConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setNamedAutoConstantReal", VALUEFUNC(_wrap_GpuProgramParameters_setNamedAutoConstantReal), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setNamedAutoConstant", VALUEFUNC(_wrap_GpuProgramParameters_setNamedAutoConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setNamedConstantFromTime", VALUEFUNC(_wrap_GpuProgramParameters_setNamedConstantFromTime), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "clearNamedAutoConstant", VALUEFUNC(_wrap_GpuProgramParameters_clearNamedAutoConstant), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_findNamedConstantDefinition", VALUEFUNC(_wrap_GpuProgramParameters__findNamedConstantDefinition), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_getFloatConstantPhysicalIndex", VALUEFUNC(_wrap_GpuProgramParameters__getFloatConstantPhysicalIndex), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_getIntConstantPhysicalIndex", VALUEFUNC(_wrap_GpuProgramParameters__getIntConstantPhysicalIndex), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "setTransposeMatrices", VALUEFUNC(_wrap_GpuProgramParameters_setTransposeMatrices), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getTransposeMatrices", VALUEFUNC(_wrap_GpuProgramParameters_getTransposeMatrices), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "copyConstantsFrom", VALUEFUNC(_wrap_GpuProgramParameters_copyConstantsFrom), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "copyMatchingNamedConstantsFrom", VALUEFUNC(_wrap_GpuProgramParameters_copyMatchingNamedConstantsFrom), -1);
  rb_define_singleton_method(SwigClassGpuProgramParameters.klass, "getAutoConstantDefinition", VALUEFUNC(_wrap_GpuProgramParameters_getAutoConstantDefinition), -1);
  rb_define_singleton_method(SwigClassGpuProgramParameters.klass, "getNumAutoConstantDefinitions", VALUEFUNC(_wrap_GpuProgramParameters_getNumAutoConstantDefinitions), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "incPassIterationNumber", VALUEFUNC(_wrap_GpuProgramParameters_incPassIterationNumber), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "hasPassIterationNumber", VALUEFUNC(_wrap_GpuProgramParameters_hasPassIterationNumber), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getPassIterationNumberIndex", VALUEFUNC(_wrap_GpuProgramParameters_getPassIterationNumberIndex), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "addSharedParameters", VALUEFUNC(_wrap_GpuProgramParameters_addSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "isUsingSharedParameters", VALUEFUNC(_wrap_GpuProgramParameters_isUsingSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "removeSharedParameters", VALUEFUNC(_wrap_GpuProgramParameters_removeSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "removeAllSharedParameters", VALUEFUNC(_wrap_GpuProgramParameters_removeAllSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "getSharedParameters", VALUEFUNC(_wrap_GpuProgramParameters_getSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_setRenderSystemData", VALUEFUNC(_wrap_GpuProgramParameters__setRenderSystemData), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_getRenderSystemData", VALUEFUNC(_wrap_GpuProgramParameters__getRenderSystemData), -1);
  rb_define_method(SwigClassGpuProgramParameters.klass, "_copySharedParams", VALUEFUNC(_wrap_GpuProgramParameters__copySharedParams), -1);
  SwigClassGpuProgramParameters.mark = 0;
  SwigClassGpuProgramParameters.destroy = (void (*)(void *)) free_Ogre_GpuProgramParameters;
  SwigClassGpuProgramParameters.trackObjects = 0;
  rb_define_const(mOgre, "GPT_VERTEX_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::GPT_VERTEX_PROGRAM)));
  rb_define_const(mOgre, "GPT_FRAGMENT_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::GPT_FRAGMENT_PROGRAM)));
  rb_define_const(mOgre, "GPT_GEOMETRY_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::GPT_GEOMETRY_PROGRAM)));
  
  SwigClassGpuProgram.klass = rb_define_class_under(mOgre, "GpuProgram", ((swig_class *) SWIGTYPE_p_Ogre__Resource->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuProgram, (void *) &SwigClassGpuProgram);
  rb_undef_alloc_func(SwigClassGpuProgram.klass);
  rb_define_method(SwigClassGpuProgram.klass, "setSourceFile", VALUEFUNC(_wrap_GpuProgram_setSourceFile), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setSource", VALUEFUNC(_wrap_GpuProgram_setSource), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getSyntaxCode", VALUEFUNC(_wrap_GpuProgram_getSyntaxCode), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setSyntaxCode", VALUEFUNC(_wrap_GpuProgram_setSyntaxCode), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getSourceFile", VALUEFUNC(_wrap_GpuProgram_getSourceFile), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getSource", VALUEFUNC(_wrap_GpuProgram_getSource), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setType", VALUEFUNC(_wrap_GpuProgram_setType), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getType", VALUEFUNC(_wrap_GpuProgram_getType), -1);
  rb_define_method(SwigClassGpuProgram.klass, "_getBindingDelegate", VALUEFUNC(_wrap_GpuProgram__getBindingDelegate), -1);
  rb_define_method(SwigClassGpuProgram.klass, "isSupported", VALUEFUNC(_wrap_GpuProgram_isSupported), -1);
  rb_define_method(SwigClassGpuProgram.klass, "createParameters", VALUEFUNC(_wrap_GpuProgram_createParameters), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setSkeletalAnimationIncluded", VALUEFUNC(_wrap_GpuProgram_setSkeletalAnimationIncluded), -1);
  rb_define_method(SwigClassGpuProgram.klass, "isSkeletalAnimationIncluded", VALUEFUNC(_wrap_GpuProgram_isSkeletalAnimationIncluded), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setMorphAnimationIncluded", VALUEFUNC(_wrap_GpuProgram_setMorphAnimationIncluded), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setPoseAnimationIncluded", VALUEFUNC(_wrap_GpuProgram_setPoseAnimationIncluded), -1);
  rb_define_method(SwigClassGpuProgram.klass, "isMorphAnimationIncluded", VALUEFUNC(_wrap_GpuProgram_isMorphAnimationIncluded), -1);
  rb_define_method(SwigClassGpuProgram.klass, "isPoseAnimationIncluded", VALUEFUNC(_wrap_GpuProgram_isPoseAnimationIncluded), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getNumberOfPosesIncluded", VALUEFUNC(_wrap_GpuProgram_getNumberOfPosesIncluded), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setVertexTextureFetchRequired", VALUEFUNC(_wrap_GpuProgram_setVertexTextureFetchRequired), -1);
  rb_define_method(SwigClassGpuProgram.klass, "isVertexTextureFetchRequired", VALUEFUNC(_wrap_GpuProgram_isVertexTextureFetchRequired), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setAdjacencyInfoRequired", VALUEFUNC(_wrap_GpuProgram_setAdjacencyInfoRequired), -1);
  rb_define_method(SwigClassGpuProgram.klass, "isAdjacencyInfoRequired", VALUEFUNC(_wrap_GpuProgram_isAdjacencyInfoRequired), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getDefaultParameters", VALUEFUNC(_wrap_GpuProgram_getDefaultParameters), -1);
  rb_define_method(SwigClassGpuProgram.klass, "hasDefaultParameters", VALUEFUNC(_wrap_GpuProgram_hasDefaultParameters), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getPassSurfaceAndLightStates", VALUEFUNC(_wrap_GpuProgram_getPassSurfaceAndLightStates), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getPassFogStates", VALUEFUNC(_wrap_GpuProgram_getPassFogStates), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getPassTransformStates", VALUEFUNC(_wrap_GpuProgram_getPassTransformStates), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getLanguage", VALUEFUNC(_wrap_GpuProgram_getLanguage), -1);
  rb_define_method(SwigClassGpuProgram.klass, "hasCompileError", VALUEFUNC(_wrap_GpuProgram_hasCompileError), -1);
  rb_define_method(SwigClassGpuProgram.klass, "resetCompileError", VALUEFUNC(_wrap_GpuProgram_resetCompileError), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setManualNamedConstants", VALUEFUNC(_wrap_GpuProgram_setManualNamedConstants), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getNamedConstants", VALUEFUNC(_wrap_GpuProgram_getNamedConstants), -1);
  rb_define_method(SwigClassGpuProgram.klass, "setManualNamedConstantsFile", VALUEFUNC(_wrap_GpuProgram_setManualNamedConstantsFile), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getManualNamedConstantsFile", VALUEFUNC(_wrap_GpuProgram_getManualNamedConstantsFile), -1);
  rb_define_method(SwigClassGpuProgram.klass, "getConstantDefinitions", VALUEFUNC(_wrap_GpuProgram_getConstantDefinitions), -1);
  SwigClassGpuProgram.mark = 0;
  SwigClassGpuProgram.destroy = (void (*)(void *)) free_Ogre_GpuProgram;
  SwigClassGpuProgram.trackObjects = 0;
  
  SwigClassGpuProgramPtr.klass = rb_define_class_under(mOgre, "GpuProgramPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuProgramPtr, (void *) &SwigClassGpuProgramPtr);
  rb_define_alloc_func(SwigClassGpuProgramPtr.klass, _wrap_GpuProgramPtr_allocate);
  rb_define_method(SwigClassGpuProgramPtr.klass, "initialize", VALUEFUNC(_wrap_new_GpuProgramPtr), -1);
  SwigClassGpuProgramPtr.mark = 0;
  SwigClassGpuProgramPtr.destroy = (void (*)(void *)) free_Ogre_GpuProgramPtr;
  SwigClassGpuProgramPtr.trackObjects = 0;
  
  SwigClassUserObjectBindings.klass = rb_define_class_under(mOgre, "UserObjectBindings", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__UserObjectBindings, (void *) &SwigClassUserObjectBindings);
  rb_define_alloc_func(SwigClassUserObjectBindings.klass, _wrap_UserObjectBindings_allocate);
  rb_define_method(SwigClassUserObjectBindings.klass, "initialize", VALUEFUNC(_wrap_new_UserObjectBindings), -1);
  rb_define_method(SwigClassUserObjectBindings.klass, "setUserAny", VALUEFUNC(_wrap_UserObjectBindings_setUserAny), -1);
  rb_define_method(SwigClassUserObjectBindings.klass, "getUserAny", VALUEFUNC(_wrap_UserObjectBindings_getUserAny), -1);
  rb_define_method(SwigClassUserObjectBindings.klass, "eraseUserAny", VALUEFUNC(_wrap_UserObjectBindings_eraseUserAny), -1);
  rb_define_method(SwigClassUserObjectBindings.klass, "clear", VALUEFUNC(_wrap_UserObjectBindings_clear), -1);
  rb_define_singleton_method(SwigClassUserObjectBindings.klass, "getEmptyUserAny", VALUEFUNC(_wrap_UserObjectBindings_getEmptyUserAny), -1);
  SwigClassUserObjectBindings.mark = 0;
  SwigClassUserObjectBindings.destroy = (void (*)(void *)) free_Ogre_UserObjectBindings;
  SwigClassUserObjectBindings.trackObjects = 0;
  
  SwigClassRenderable.klass = rb_define_class_under(mOgre, "Renderable", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Renderable, (void *) &SwigClassRenderable);
  rb_undef_alloc_func(SwigClassRenderable.klass);
  rb_define_method(SwigClassRenderable.klass, "getMaterial", VALUEFUNC(_wrap_Renderable_getMaterial), -1);
  rb_define_method(SwigClassRenderable.klass, "getTechnique", VALUEFUNC(_wrap_Renderable_getTechnique), -1);
  rb_define_method(SwigClassRenderable.klass, "getRenderOperation", VALUEFUNC(_wrap_Renderable_getRenderOperation), -1);
  rb_define_method(SwigClassRenderable.klass, "preRender", VALUEFUNC(_wrap_Renderable_preRender), -1);
  rb_define_method(SwigClassRenderable.klass, "postRender", VALUEFUNC(_wrap_Renderable_postRender), -1);
  rb_define_method(SwigClassRenderable.klass, "getWorldTransforms", VALUEFUNC(_wrap_Renderable_getWorldTransforms), -1);
  rb_define_method(SwigClassRenderable.klass, "getNumWorldTransforms", VALUEFUNC(_wrap_Renderable_getNumWorldTransforms), -1);
  rb_define_method(SwigClassRenderable.klass, "setUseIdentityProjection", VALUEFUNC(_wrap_Renderable_setUseIdentityProjection), -1);
  rb_define_method(SwigClassRenderable.klass, "getUseIdentityProjection", VALUEFUNC(_wrap_Renderable_getUseIdentityProjection), -1);
  rb_define_method(SwigClassRenderable.klass, "setUseIdentityView", VALUEFUNC(_wrap_Renderable_setUseIdentityView), -1);
  rb_define_method(SwigClassRenderable.klass, "getUseIdentityView", VALUEFUNC(_wrap_Renderable_getUseIdentityView), -1);
  rb_define_method(SwigClassRenderable.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_Renderable_getSquaredViewDepth), -1);
  rb_define_method(SwigClassRenderable.klass, "getLights", VALUEFUNC(_wrap_Renderable_getLights), -1);
  rb_define_method(SwigClassRenderable.klass, "getCastsShadows", VALUEFUNC(_wrap_Renderable_getCastsShadows), -1);
  rb_define_method(SwigClassRenderable.klass, "setCustomParameter", VALUEFUNC(_wrap_Renderable_setCustomParameter), -1);
  rb_define_method(SwigClassRenderable.klass, "removeCustomParameter", VALUEFUNC(_wrap_Renderable_removeCustomParameter), -1);
  rb_define_method(SwigClassRenderable.klass, "hasCustomParameter", VALUEFUNC(_wrap_Renderable_hasCustomParameter), -1);
  rb_define_method(SwigClassRenderable.klass, "getCustomParameter", VALUEFUNC(_wrap_Renderable_getCustomParameter), -1);
  rb_define_method(SwigClassRenderable.klass, "_updateCustomGpuParameter", VALUEFUNC(_wrap_Renderable__updateCustomGpuParameter), -1);
  rb_define_method(SwigClassRenderable.klass, "setPolygonModeOverrideable", VALUEFUNC(_wrap_Renderable_setPolygonModeOverrideable), -1);
  rb_define_method(SwigClassRenderable.klass, "getPolygonModeOverrideable", VALUEFUNC(_wrap_Renderable_getPolygonModeOverrideable), -1);
  rb_define_method(SwigClassRenderable.klass, "setUserAny", VALUEFUNC(_wrap_Renderable_setUserAny), -1);
  rb_define_method(SwigClassRenderable.klass, "getUserAny", VALUEFUNC(_wrap_Renderable_getUserAny), -1);
  rb_define_method(SwigClassRenderable.klass, "getUserObjectBindings", VALUEFUNC(_wrap_Renderable_getUserObjectBindings), -1);
  rb_define_method(SwigClassRenderable.klass, "getRenderSystemData", VALUEFUNC(_wrap_Renderable_getRenderSystemData), -1);
  rb_define_method(SwigClassRenderable.klass, "setRenderSystemData", VALUEFUNC(_wrap_Renderable_setRenderSystemData), -1);
  SwigClassRenderable.mark = 0;
  SwigClassRenderable.destroy = (void (*)(void *)) free_Ogre_Renderable;
  SwigClassRenderable.trackObjects = 0;
  
  SwigClassShadowRenderable.klass = rb_define_class_under(mOgre, "ShadowRenderable", ((swig_class *) SWIGTYPE_p_Ogre__Renderable->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ShadowRenderable, (void *) &SwigClassShadowRenderable);
  rb_undef_alloc_func(SwigClassShadowRenderable.klass);
  rb_define_method(SwigClassShadowRenderable.klass, "setMaterial", VALUEFUNC(_wrap_ShadowRenderable_setMaterial), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "getMaterial", VALUEFUNC(_wrap_ShadowRenderable_getMaterial), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "getRenderOperation", VALUEFUNC(_wrap_ShadowRenderable_getRenderOperation), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "getRenderOperationForUpdate", VALUEFUNC(_wrap_ShadowRenderable_getRenderOperationForUpdate), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "getWorldTransforms", VALUEFUNC(_wrap_ShadowRenderable_getWorldTransforms), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_ShadowRenderable_getSquaredViewDepth), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "getLights", VALUEFUNC(_wrap_ShadowRenderable_getLights), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "isLightCapSeparate", VALUEFUNC(_wrap_ShadowRenderable_isLightCapSeparate), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "getLightCapRenderable", VALUEFUNC(_wrap_ShadowRenderable_getLightCapRenderable), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "isVisible", VALUEFUNC(_wrap_ShadowRenderable_isVisible), -1);
  rb_define_method(SwigClassShadowRenderable.klass, "rebindIndexBuffer", VALUEFUNC(_wrap_ShadowRenderable_rebindIndexBuffer), -1);
  SwigClassShadowRenderable.mark = 0;
  SwigClassShadowRenderable.destroy = (void (*)(void *)) free_Ogre_ShadowRenderable;
  SwigClassShadowRenderable.trackObjects = 0;
  rb_define_const(mOgre, "SRF_INCLUDE_LIGHT_CAP", SWIG_From_int(static_cast< int >(Ogre::SRF_INCLUDE_LIGHT_CAP)));
  rb_define_const(mOgre, "SRF_INCLUDE_DARK_CAP", SWIG_From_int(static_cast< int >(Ogre::SRF_INCLUDE_DARK_CAP)));
  rb_define_const(mOgre, "SRF_EXTRUDE_TO_INFINITY", SWIG_From_int(static_cast< int >(Ogre::SRF_EXTRUDE_TO_INFINITY)));
  
  SwigClassShadowCaster.klass = rb_define_class_under(mOgre, "ShadowCaster", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ShadowCaster, (void *) &SwigClassShadowCaster);
  rb_undef_alloc_func(SwigClassShadowCaster.klass);
  rb_define_method(SwigClassShadowCaster.klass, "getCastShadows", VALUEFUNC(_wrap_ShadowCaster_getCastShadows), -1);
  rb_define_method(SwigClassShadowCaster.klass, "getEdgeList", VALUEFUNC(_wrap_ShadowCaster_getEdgeList), -1);
  rb_define_method(SwigClassShadowCaster.klass, "hasEdgeList", VALUEFUNC(_wrap_ShadowCaster_hasEdgeList), -1);
  rb_define_method(SwigClassShadowCaster.klass, "getWorldBoundingBox", VALUEFUNC(_wrap_ShadowCaster_getWorldBoundingBox), -1);
  rb_define_method(SwigClassShadowCaster.klass, "getLightCapBounds", VALUEFUNC(_wrap_ShadowCaster_getLightCapBounds), -1);
  rb_define_method(SwigClassShadowCaster.klass, "getDarkCapBounds", VALUEFUNC(_wrap_ShadowCaster_getDarkCapBounds), -1);
  rb_define_method(SwigClassShadowCaster.klass, "getShadowVolumeRenderableIterator", VALUEFUNC(_wrap_ShadowCaster_getShadowVolumeRenderableIterator), -1);
  rb_define_singleton_method(SwigClassShadowCaster.klass, "extrudeVertices", VALUEFUNC(_wrap_ShadowCaster_extrudeVertices), -1);
  rb_define_method(SwigClassShadowCaster.klass, "getPointExtrusionDistance", VALUEFUNC(_wrap_ShadowCaster_getPointExtrusionDistance), -1);
  SwigClassShadowCaster.mark = 0;
  SwigClassShadowCaster.destroy = (void (*)(void *)) free_Ogre_ShadowCaster;
  SwigClassShadowCaster.trackObjects = 0;
  
  SwigClassMovableObject.klass = rb_define_class_under(mOgre, "MovableObject", ((swig_class *) SWIGTYPE_p_Ogre__ShadowCaster->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MovableObject, (void *) &SwigClassMovableObject);
  rb_undef_alloc_func(SwigClassMovableObject.klass);
  rb_define_method(SwigClassMovableObject.klass, "_notifyCreator", VALUEFUNC(_wrap_MovableObject__notifyCreator), -1);
  rb_define_method(SwigClassMovableObject.klass, "_getCreator", VALUEFUNC(_wrap_MovableObject__getCreator), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notifyManager", VALUEFUNC(_wrap_MovableObject__notifyManager), -1);
  rb_define_method(SwigClassMovableObject.klass, "_getManager", VALUEFUNC(_wrap_MovableObject__getManager), -1);
  rb_define_method(SwigClassMovableObject.klass, "getName", VALUEFUNC(_wrap_MovableObject_getName), -1);
  rb_define_method(SwigClassMovableObject.klass, "getMovableType", VALUEFUNC(_wrap_MovableObject_getMovableType), -1);
  rb_define_method(SwigClassMovableObject.klass, "getParentNode", VALUEFUNC(_wrap_MovableObject_getParentNode), -1);
  rb_define_method(SwigClassMovableObject.klass, "getParentSceneNode", VALUEFUNC(_wrap_MovableObject_getParentSceneNode), -1);
  rb_define_method(SwigClassMovableObject.klass, "isParentTagPoint", VALUEFUNC(_wrap_MovableObject_isParentTagPoint), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notifyAttached", VALUEFUNC(_wrap_MovableObject__notifyAttached), -1);
  rb_define_method(SwigClassMovableObject.klass, "isAttached", VALUEFUNC(_wrap_MovableObject_isAttached), -1);
  rb_define_method(SwigClassMovableObject.klass, "detachFromParent", VALUEFUNC(_wrap_MovableObject_detachFromParent), -1);
  rb_define_method(SwigClassMovableObject.klass, "isInScene", VALUEFUNC(_wrap_MovableObject_isInScene), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notifyMoved", VALUEFUNC(_wrap_MovableObject__notifyMoved), -1);
  rb_define_method(SwigClassMovableObject.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_MovableObject__notifyCurrentCamera), -1);
  rb_define_method(SwigClassMovableObject.klass, "getBoundingBox", VALUEFUNC(_wrap_MovableObject_getBoundingBox), -1);
  rb_define_method(SwigClassMovableObject.klass, "getBoundingRadius", VALUEFUNC(_wrap_MovableObject_getBoundingRadius), -1);
  rb_define_method(SwigClassMovableObject.klass, "getWorldBoundingBox", VALUEFUNC(_wrap_MovableObject_getWorldBoundingBox), -1);
  rb_define_method(SwigClassMovableObject.klass, "getWorldBoundingSphere", VALUEFUNC(_wrap_MovableObject_getWorldBoundingSphere), -1);
  rb_define_method(SwigClassMovableObject.klass, "_updateRenderQueue", VALUEFUNC(_wrap_MovableObject__updateRenderQueue), -1);
  rb_define_method(SwigClassMovableObject.klass, "setVisible", VALUEFUNC(_wrap_MovableObject_setVisible), -1);
  rb_define_method(SwigClassMovableObject.klass, "getVisible", VALUEFUNC(_wrap_MovableObject_getVisible), -1);
  rb_define_method(SwigClassMovableObject.klass, "isVisible", VALUEFUNC(_wrap_MovableObject_isVisible), -1);
  rb_define_method(SwigClassMovableObject.klass, "setRenderingDistance", VALUEFUNC(_wrap_MovableObject_setRenderingDistance), -1);
  rb_define_method(SwigClassMovableObject.klass, "getRenderingDistance", VALUEFUNC(_wrap_MovableObject_getRenderingDistance), -1);
  rb_define_method(SwigClassMovableObject.klass, "setRenderingMinPixelSize", VALUEFUNC(_wrap_MovableObject_setRenderingMinPixelSize), -1);
  rb_define_method(SwigClassMovableObject.klass, "getRenderingMinPixelSize", VALUEFUNC(_wrap_MovableObject_getRenderingMinPixelSize), -1);
  rb_define_method(SwigClassMovableObject.klass, "setUserAny", VALUEFUNC(_wrap_MovableObject_setUserAny), -1);
  rb_define_method(SwigClassMovableObject.klass, "getUserAny", VALUEFUNC(_wrap_MovableObject_getUserAny), -1);
  rb_define_method(SwigClassMovableObject.klass, "getUserObjectBindings", VALUEFUNC(_wrap_MovableObject_getUserObjectBindings), -1);
  rb_define_method(SwigClassMovableObject.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_MovableObject_setRenderQueueGroup), -1);
  rb_define_method(SwigClassMovableObject.klass, "setRenderQueueGroupAndPriority", VALUEFUNC(_wrap_MovableObject_setRenderQueueGroupAndPriority), -1);
  rb_define_method(SwigClassMovableObject.klass, "getRenderQueueGroup", VALUEFUNC(_wrap_MovableObject_getRenderQueueGroup), -1);
  rb_define_method(SwigClassMovableObject.klass, "_getParentNodeFullTransform", VALUEFUNC(_wrap_MovableObject__getParentNodeFullTransform), -1);
  rb_define_method(SwigClassMovableObject.klass, "setQueryFlags", VALUEFUNC(_wrap_MovableObject_setQueryFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "addQueryFlags", VALUEFUNC(_wrap_MovableObject_addQueryFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "removeQueryFlags", VALUEFUNC(_wrap_MovableObject_removeQueryFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "getQueryFlags", VALUEFUNC(_wrap_MovableObject_getQueryFlags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "setDefaultQueryFlags", VALUEFUNC(_wrap_MovableObject_setDefaultQueryFlags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "getDefaultQueryFlags", VALUEFUNC(_wrap_MovableObject_getDefaultQueryFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "setVisibilityFlags", VALUEFUNC(_wrap_MovableObject_setVisibilityFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "addVisibilityFlags", VALUEFUNC(_wrap_MovableObject_addVisibilityFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "removeVisibilityFlags", VALUEFUNC(_wrap_MovableObject_removeVisibilityFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "getVisibilityFlags", VALUEFUNC(_wrap_MovableObject_getVisibilityFlags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "setDefaultVisibilityFlags", VALUEFUNC(_wrap_MovableObject_setDefaultVisibilityFlags), -1);
  rb_define_singleton_method(SwigClassMovableObject.klass, "getDefaultVisibilityFlags", VALUEFUNC(_wrap_MovableObject_getDefaultVisibilityFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "setListener", VALUEFUNC(_wrap_MovableObject_setListener), -1);
  rb_define_method(SwigClassMovableObject.klass, "getListener", VALUEFUNC(_wrap_MovableObject_getListener), -1);
  rb_define_method(SwigClassMovableObject.klass, "queryLights", VALUEFUNC(_wrap_MovableObject_queryLights), -1);
  rb_define_method(SwigClassMovableObject.klass, "getLightMask", VALUEFUNC(_wrap_MovableObject_getLightMask), -1);
  rb_define_method(SwigClassMovableObject.klass, "setLightMask", VALUEFUNC(_wrap_MovableObject_setLightMask), -1);
  rb_define_method(SwigClassMovableObject.klass, "_getLightList", VALUEFUNC(_wrap_MovableObject__getLightList), -1);
  rb_define_method(SwigClassMovableObject.klass, "getEdgeList", VALUEFUNC(_wrap_MovableObject_getEdgeList), -1);
  rb_define_method(SwigClassMovableObject.klass, "hasEdgeList", VALUEFUNC(_wrap_MovableObject_hasEdgeList), -1);
  rb_define_method(SwigClassMovableObject.klass, "getShadowVolumeRenderableIterator", VALUEFUNC(_wrap_MovableObject_getShadowVolumeRenderableIterator), -1);
  rb_define_method(SwigClassMovableObject.klass, "getLightCapBounds", VALUEFUNC(_wrap_MovableObject_getLightCapBounds), -1);
  rb_define_method(SwigClassMovableObject.klass, "getDarkCapBounds", VALUEFUNC(_wrap_MovableObject_getDarkCapBounds), -1);
  rb_define_method(SwigClassMovableObject.klass, "setCastShadows", VALUEFUNC(_wrap_MovableObject_setCastShadows), -1);
  rb_define_method(SwigClassMovableObject.klass, "getCastShadows", VALUEFUNC(_wrap_MovableObject_getCastShadows), -1);
  rb_define_method(SwigClassMovableObject.klass, "getReceivesShadows", VALUEFUNC(_wrap_MovableObject_getReceivesShadows), -1);
  rb_define_method(SwigClassMovableObject.klass, "getPointExtrusionDistance", VALUEFUNC(_wrap_MovableObject_getPointExtrusionDistance), -1);
  rb_define_method(SwigClassMovableObject.klass, "getTypeFlags", VALUEFUNC(_wrap_MovableObject_getTypeFlags), -1);
  rb_define_method(SwigClassMovableObject.klass, "visitRenderables", VALUEFUNC(_wrap_MovableObject_visitRenderables), -1);
  rb_define_method(SwigClassMovableObject.klass, "setDebugDisplayEnabled", VALUEFUNC(_wrap_MovableObject_setDebugDisplayEnabled), -1);
  rb_define_method(SwigClassMovableObject.klass, "isDebugDisplayEnabled", VALUEFUNC(_wrap_MovableObject_isDebugDisplayEnabled), -1);
  SwigClassMovableObject.mark = 0;
  SwigClassMovableObject.destroy = (void (*)(void *)) free_Ogre_MovableObject;
  SwigClassMovableObject.trackObjects = 0;
  
  SwigClassMovableObjectFactory.klass = rb_define_class_under(mOgre, "MovableObjectFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MovableObjectFactory, (void *) &SwigClassMovableObjectFactory);
  rb_undef_alloc_func(SwigClassMovableObjectFactory.klass);
  rb_define_method(SwigClassMovableObjectFactory.klass, "getType", VALUEFUNC(_wrap_MovableObjectFactory_getType), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "createInstance", VALUEFUNC(_wrap_MovableObjectFactory_createInstance), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "destroyInstance", VALUEFUNC(_wrap_MovableObjectFactory_destroyInstance), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "requestTypeFlags", VALUEFUNC(_wrap_MovableObjectFactory_requestTypeFlags), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "_notifyTypeFlags", VALUEFUNC(_wrap_MovableObjectFactory__notifyTypeFlags), -1);
  rb_define_method(SwigClassMovableObjectFactory.klass, "getTypeFlags", VALUEFUNC(_wrap_MovableObjectFactory_getTypeFlags), -1);
  SwigClassMovableObjectFactory.mark = 0;
  SwigClassMovableObjectFactory.destroy = (void (*)(void *)) free_Ogre_MovableObjectFactory;
  SwigClassMovableObjectFactory.trackObjects = 0;
  
  SwigClassPlaneBoundedVolume.klass = rb_define_class_under(mOgre, "PlaneBoundedVolume", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PlaneBoundedVolume, (void *) &SwigClassPlaneBoundedVolume);
  rb_define_alloc_func(SwigClassPlaneBoundedVolume.klass, _wrap_PlaneBoundedVolume_allocate);
  rb_define_method(SwigClassPlaneBoundedVolume.klass, "initialize", VALUEFUNC(_wrap_new_PlaneBoundedVolume), -1);
  rb_define_method(SwigClassPlaneBoundedVolume.klass, "planes=", VALUEFUNC(_wrap_PlaneBoundedVolume_planes_set), -1);
  rb_define_method(SwigClassPlaneBoundedVolume.klass, "planes", VALUEFUNC(_wrap_PlaneBoundedVolume_planes_get), -1);
  rb_define_method(SwigClassPlaneBoundedVolume.klass, "outside=", VALUEFUNC(_wrap_PlaneBoundedVolume_outside_set), -1);
  rb_define_method(SwigClassPlaneBoundedVolume.klass, "outside", VALUEFUNC(_wrap_PlaneBoundedVolume_outside_get), -1);
  rb_define_method(SwigClassPlaneBoundedVolume.klass, "intersects", VALUEFUNC(_wrap_PlaneBoundedVolume_intersects), -1);
  SwigClassPlaneBoundedVolume.mark = 0;
  SwigClassPlaneBoundedVolume.destroy = (void (*)(void *)) free_Ogre_PlaneBoundedVolume;
  SwigClassPlaneBoundedVolume.trackObjects = 0;
  
  SwigClassMovablePlane.klass = rb_define_class_under(mOgre, "MovablePlane", ((swig_class *) SWIGTYPE_p_Ogre__Plane->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MovablePlane, (void *) &SwigClassMovablePlane);
  rb_define_alloc_func(SwigClassMovablePlane.klass, _wrap_MovablePlane_allocate);
  rb_define_method(SwigClassMovablePlane.klass, "initialize", VALUEFUNC(_wrap_new_MovablePlane), -1);
  rb_define_method(SwigClassMovablePlane.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_MovablePlane__notifyCurrentCamera), -1);
  rb_define_method(SwigClassMovablePlane.klass, "getBoundingBox", VALUEFUNC(_wrap_MovablePlane_getBoundingBox), -1);
  rb_define_method(SwigClassMovablePlane.klass, "getBoundingRadius", VALUEFUNC(_wrap_MovablePlane_getBoundingRadius), -1);
  rb_define_method(SwigClassMovablePlane.klass, "_updateRenderQueue", VALUEFUNC(_wrap_MovablePlane__updateRenderQueue), -1);
  rb_define_method(SwigClassMovablePlane.klass, "getMovableType", VALUEFUNC(_wrap_MovablePlane_getMovableType), -1);
  rb_define_method(SwigClassMovablePlane.klass, "_getDerivedPlane", VALUEFUNC(_wrap_MovablePlane__getDerivedPlane), -1);
  rb_define_method(SwigClassMovablePlane.klass, "visitRenderables", VALUEFUNC(_wrap_MovablePlane_visitRenderables), -1);
  SwigClassMovablePlane.mark = 0;
  SwigClassMovablePlane.destroy = (void (*)(void *)) free_Ogre_MovablePlane;
  SwigClassMovablePlane.trackObjects = 0;
  
  SwigClassShadowCameraSetup.klass = rb_define_class_under(mOgre, "ShadowCameraSetup", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ShadowCameraSetup, (void *) &SwigClassShadowCameraSetup);
  rb_undef_alloc_func(SwigClassShadowCameraSetup.klass);
  rb_define_method(SwigClassShadowCameraSetup.klass, "getShadowCamera", VALUEFUNC(_wrap_ShadowCameraSetup_getShadowCamera), -1);
  SwigClassShadowCameraSetup.mark = 0;
  SwigClassShadowCameraSetup.destroy = (void (*)(void *)) free_Ogre_ShadowCameraSetup;
  SwigClassShadowCameraSetup.trackObjects = 0;
  
  SwigClassDefaultShadowCameraSetup.klass = rb_define_class_under(mOgre, "DefaultShadowCameraSetup", ((swig_class *) SWIGTYPE_p_Ogre__ShadowCameraSetup->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultShadowCameraSetup, (void *) &SwigClassDefaultShadowCameraSetup);
  rb_define_alloc_func(SwigClassDefaultShadowCameraSetup.klass, _wrap_DefaultShadowCameraSetup_allocate);
  rb_define_method(SwigClassDefaultShadowCameraSetup.klass, "initialize", VALUEFUNC(_wrap_new_DefaultShadowCameraSetup), -1);
  rb_define_method(SwigClassDefaultShadowCameraSetup.klass, "getShadowCamera", VALUEFUNC(_wrap_DefaultShadowCameraSetup_getShadowCamera), -1);
  SwigClassDefaultShadowCameraSetup.mark = 0;
  SwigClassDefaultShadowCameraSetup.destroy = (void (*)(void *)) free_Ogre_DefaultShadowCameraSetup;
  SwigClassDefaultShadowCameraSetup.trackObjects = 0;
  
  SwigClassLight.klass = rb_define_class_under(mOgre, "Light", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Light, (void *) &SwigClassLight);
  rb_define_alloc_func(SwigClassLight.klass, _wrap_Light_allocate);
  rb_define_method(SwigClassLight.klass, "initialize", VALUEFUNC(_wrap_new_Light), -1);
  rb_define_method(SwigClassLight.klass, "tempSquareDist=", VALUEFUNC(_wrap_Light_tempSquareDist_set), -1);
  rb_define_method(SwigClassLight.klass, "tempSquareDist", VALUEFUNC(_wrap_Light_tempSquareDist_get), -1);
  rb_define_method(SwigClassLight.klass, "_calcTempSquareDist", VALUEFUNC(_wrap_Light__calcTempSquareDist), -1);
  rb_define_const(SwigClassLight.klass, "LT_POINT", SWIG_From_int(static_cast< int >(Ogre::Light::LT_POINT)));
  rb_define_const(SwigClassLight.klass, "LT_DIRECTIONAL", SWIG_From_int(static_cast< int >(Ogre::Light::LT_DIRECTIONAL)));
  rb_define_const(SwigClassLight.klass, "LT_SPOTLIGHT", SWIG_From_int(static_cast< int >(Ogre::Light::LT_SPOTLIGHT)));
  rb_define_method(SwigClassLight.klass, "setType", VALUEFUNC(_wrap_Light_setType), -1);
  rb_define_method(SwigClassLight.klass, "getType", VALUEFUNC(_wrap_Light_getType), -1);
  rb_define_method(SwigClassLight.klass, "setDiffuseColour", VALUEFUNC(_wrap_Light_setDiffuseColour), -1);
  rb_define_method(SwigClassLight.klass, "getDiffuseColour", VALUEFUNC(_wrap_Light_getDiffuseColour), -1);
  rb_define_method(SwigClassLight.klass, "setSpecularColour", VALUEFUNC(_wrap_Light_setSpecularColour), -1);
  rb_define_method(SwigClassLight.klass, "getSpecularColour", VALUEFUNC(_wrap_Light_getSpecularColour), -1);
  rb_define_method(SwigClassLight.klass, "setAttenuation", VALUEFUNC(_wrap_Light_setAttenuation), -1);
  rb_define_method(SwigClassLight.klass, "getAttenuationRange", VALUEFUNC(_wrap_Light_getAttenuationRange), -1);
  rb_define_method(SwigClassLight.klass, "getAttenuationConstant", VALUEFUNC(_wrap_Light_getAttenuationConstant), -1);
  rb_define_method(SwigClassLight.klass, "getAttenuationLinear", VALUEFUNC(_wrap_Light_getAttenuationLinear), -1);
  rb_define_method(SwigClassLight.klass, "getAttenuationQuadric", VALUEFUNC(_wrap_Light_getAttenuationQuadric), -1);
  rb_define_method(SwigClassLight.klass, "setPosition", VALUEFUNC(_wrap_Light_setPosition), -1);
  rb_define_method(SwigClassLight.klass, "getPosition", VALUEFUNC(_wrap_Light_getPosition), -1);
  rb_define_method(SwigClassLight.klass, "setDirection", VALUEFUNC(_wrap_Light_setDirection), -1);
  rb_define_method(SwigClassLight.klass, "getDirection", VALUEFUNC(_wrap_Light_getDirection), -1);
  rb_define_method(SwigClassLight.klass, "setSpotlightRange", VALUEFUNC(_wrap_Light_setSpotlightRange), -1);
  rb_define_method(SwigClassLight.klass, "getSpotlightInnerAngle", VALUEFUNC(_wrap_Light_getSpotlightInnerAngle), -1);
  rb_define_method(SwigClassLight.klass, "getSpotlightOuterAngle", VALUEFUNC(_wrap_Light_getSpotlightOuterAngle), -1);
  rb_define_method(SwigClassLight.klass, "getSpotlightFalloff", VALUEFUNC(_wrap_Light_getSpotlightFalloff), -1);
  rb_define_method(SwigClassLight.klass, "setSpotlightInnerAngle", VALUEFUNC(_wrap_Light_setSpotlightInnerAngle), -1);
  rb_define_method(SwigClassLight.klass, "setSpotlightOuterAngle", VALUEFUNC(_wrap_Light_setSpotlightOuterAngle), -1);
  rb_define_method(SwigClassLight.klass, "setSpotlightFalloff", VALUEFUNC(_wrap_Light_setSpotlightFalloff), -1);
  rb_define_method(SwigClassLight.klass, "setSpotlightNearClipDistance", VALUEFUNC(_wrap_Light_setSpotlightNearClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "getSpotlightNearClipDistance", VALUEFUNC(_wrap_Light_getSpotlightNearClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "setPowerScale", VALUEFUNC(_wrap_Light_setPowerScale), -1);
  rb_define_method(SwigClassLight.klass, "getPowerScale", VALUEFUNC(_wrap_Light_getPowerScale), -1);
  rb_define_method(SwigClassLight.klass, "_notifyAttached", VALUEFUNC(_wrap_Light__notifyAttached), -1);
  rb_define_method(SwigClassLight.klass, "_notifyMoved", VALUEFUNC(_wrap_Light__notifyMoved), -1);
  rb_define_method(SwigClassLight.klass, "getBoundingBox", VALUEFUNC(_wrap_Light_getBoundingBox), -1);
  rb_define_method(SwigClassLight.klass, "_updateRenderQueue", VALUEFUNC(_wrap_Light__updateRenderQueue), -1);
  rb_define_method(SwigClassLight.klass, "getMovableType", VALUEFUNC(_wrap_Light_getMovableType), -1);
  rb_define_method(SwigClassLight.klass, "getDerivedPosition", VALUEFUNC(_wrap_Light_getDerivedPosition), -1);
  rb_define_method(SwigClassLight.klass, "getDerivedDirection", VALUEFUNC(_wrap_Light_getDerivedDirection), -1);
  rb_define_method(SwigClassLight.klass, "setVisible", VALUEFUNC(_wrap_Light_setVisible), -1);
  rb_define_method(SwigClassLight.klass, "getBoundingRadius", VALUEFUNC(_wrap_Light_getBoundingRadius), -1);
  rb_define_method(SwigClassLight.klass, "getAs4DVector", VALUEFUNC(_wrap_Light_getAs4DVector), -1);
  rb_define_method(SwigClassLight.klass, "_getNearClipVolume", VALUEFUNC(_wrap_Light__getNearClipVolume), -1);
  rb_define_method(SwigClassLight.klass, "_getFrustumClipVolumes", VALUEFUNC(_wrap_Light__getFrustumClipVolumes), -1);
  rb_define_method(SwigClassLight.klass, "getTypeFlags", VALUEFUNC(_wrap_Light_getTypeFlags), -1);
  rb_define_method(SwigClassLight.klass, "createAnimableValue", VALUEFUNC(_wrap_Light_createAnimableValue), -1);
  rb_define_method(SwigClassLight.klass, "setCustomShadowCameraSetup", VALUEFUNC(_wrap_Light_setCustomShadowCameraSetup), -1);
  rb_define_method(SwigClassLight.klass, "resetCustomShadowCameraSetup", VALUEFUNC(_wrap_Light_resetCustomShadowCameraSetup), -1);
  rb_define_method(SwigClassLight.klass, "getCustomShadowCameraSetup", VALUEFUNC(_wrap_Light_getCustomShadowCameraSetup), -1);
  rb_define_method(SwigClassLight.klass, "visitRenderables", VALUEFUNC(_wrap_Light_visitRenderables), -1);
  rb_define_method(SwigClassLight.klass, "_getIndexInFrame", VALUEFUNC(_wrap_Light__getIndexInFrame), -1);
  rb_define_method(SwigClassLight.klass, "_notifyIndexInFrame", VALUEFUNC(_wrap_Light__notifyIndexInFrame), -1);
  rb_define_method(SwigClassLight.klass, "setShadowFarDistance", VALUEFUNC(_wrap_Light_setShadowFarDistance), -1);
  rb_define_method(SwigClassLight.klass, "resetShadowFarDistance", VALUEFUNC(_wrap_Light_resetShadowFarDistance), -1);
  rb_define_method(SwigClassLight.klass, "getShadowFarDistance", VALUEFUNC(_wrap_Light_getShadowFarDistance), -1);
  rb_define_method(SwigClassLight.klass, "getShadowFarDistanceSquared", VALUEFUNC(_wrap_Light_getShadowFarDistanceSquared), -1);
  rb_define_method(SwigClassLight.klass, "setShadowNearClipDistance", VALUEFUNC(_wrap_Light_setShadowNearClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "getShadowNearClipDistance", VALUEFUNC(_wrap_Light_getShadowNearClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "_deriveShadowNearClipDistance", VALUEFUNC(_wrap_Light__deriveShadowNearClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "setShadowFarClipDistance", VALUEFUNC(_wrap_Light_setShadowFarClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "getShadowFarClipDistance", VALUEFUNC(_wrap_Light_getShadowFarClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "_deriveShadowFarClipDistance", VALUEFUNC(_wrap_Light__deriveShadowFarClipDistance), -1);
  rb_define_method(SwigClassLight.klass, "_setCameraRelative", VALUEFUNC(_wrap_Light__setCameraRelative), -1);
  rb_define_method(SwigClassLight.klass, "setCustomParameter", VALUEFUNC(_wrap_Light_setCustomParameter), -1);
  rb_define_method(SwigClassLight.klass, "getCustomParameter", VALUEFUNC(_wrap_Light_getCustomParameter), -1);
  rb_define_method(SwigClassLight.klass, "_updateCustomGpuParameter", VALUEFUNC(_wrap_Light__updateCustomGpuParameter), -1);
  SwigClassLight.mark = 0;
  SwigClassLight.destroy = (void (*)(void *)) free_Ogre_Light;
  SwigClassLight.trackObjects = 0;
  
  SwigClassLightFactory.klass = rb_define_class_under(mOgre, "LightFactory", ((swig_class *) SWIGTYPE_p_Ogre__MovableObjectFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LightFactory, (void *) &SwigClassLightFactory);
  rb_undef_alloc_func(SwigClassLightFactory.klass);
  rb_define_singleton_method(SwigClassLightFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_LightFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_singleton_method(SwigClassLightFactory.klass, "FACTORY_TYPE_NAME=", VALUEFUNC(_wrap_LightFactory_FACTORY_TYPE_NAME_set), 1);
  rb_define_method(SwigClassLightFactory.klass, "getType", VALUEFUNC(_wrap_LightFactory_getType), -1);
  rb_define_method(SwigClassLightFactory.klass, "destroyInstance", VALUEFUNC(_wrap_LightFactory_destroyInstance), -1);
  SwigClassLightFactory.mark = 0;
  SwigClassLightFactory.destroy = (void (*)(void *)) free_Ogre_LightFactory;
  SwigClassLightFactory.trackObjects = 0;
  
  SwigClassAutoParamDataSource.klass = rb_define_class_under(mOgre, "AutoParamDataSource", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AutoParamDataSource, (void *) &SwigClassAutoParamDataSource);
  rb_define_alloc_func(SwigClassAutoParamDataSource.klass, _wrap_AutoParamDataSource_allocate);
  rb_define_method(SwigClassAutoParamDataSource.klass, "initialize", VALUEFUNC(_wrap_new_AutoParamDataSource), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setCurrentRenderable", VALUEFUNC(_wrap_AutoParamDataSource_setCurrentRenderable), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setWorldMatrices", VALUEFUNC(_wrap_AutoParamDataSource_setWorldMatrices), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setCurrentCamera", VALUEFUNC(_wrap_AutoParamDataSource_setCurrentCamera), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setCurrentLightList", VALUEFUNC(_wrap_AutoParamDataSource_setCurrentLightList), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setTextureProjector", VALUEFUNC(_wrap_AutoParamDataSource_setTextureProjector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setCurrentRenderTarget", VALUEFUNC(_wrap_AutoParamDataSource_setCurrentRenderTarget), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setCurrentViewport", VALUEFUNC(_wrap_AutoParamDataSource_setCurrentViewport), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setShadowDirLightExtrusionDistance", VALUEFUNC(_wrap_AutoParamDataSource_setShadowDirLightExtrusionDistance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setMainCamBoundsInfo", VALUEFUNC(_wrap_AutoParamDataSource_setMainCamBoundsInfo), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setCurrentSceneManager", VALUEFUNC(_wrap_AutoParamDataSource_setCurrentSceneManager), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setCurrentPass", VALUEFUNC(_wrap_AutoParamDataSource_setCurrentPass), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getWorldMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getWorldMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getWorldMatrixArray", VALUEFUNC(_wrap_AutoParamDataSource_getWorldMatrixArray), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getWorldMatrixCount", VALUEFUNC(_wrap_AutoParamDataSource_getWorldMatrixCount), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getViewProjectionMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getViewProjectionMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getProjectionMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getProjectionMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getWorldViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getWorldViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getWorldViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getWorldViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseWorldMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseWorldMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseWorldViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseWorldViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseTransposeWorldMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseTransposeWorldMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseTransposeWorldViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseTransposeWorldViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCameraPosition", VALUEFUNC(_wrap_AutoParamDataSource_getCameraPosition), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCameraPositionObjectSpace", VALUEFUNC(_wrap_AutoParamDataSource_getCameraPositionObjectSpace), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLodCameraPosition", VALUEFUNC(_wrap_AutoParamDataSource_getLodCameraPosition), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLodCameraPositionObjectSpace", VALUEFUNC(_wrap_AutoParamDataSource_getLodCameraPositionObjectSpace), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "hasLightList", VALUEFUNC(_wrap_AutoParamDataSource_hasLightList), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightNumber", VALUEFUNC(_wrap_AutoParamDataSource_getLightNumber), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightCount", VALUEFUNC(_wrap_AutoParamDataSource_getLightCount), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightCastsShadows", VALUEFUNC(_wrap_AutoParamDataSource_getLightCastsShadows), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightDiffuseColour", VALUEFUNC(_wrap_AutoParamDataSource_getLightDiffuseColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightSpecularColour", VALUEFUNC(_wrap_AutoParamDataSource_getLightSpecularColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightDiffuseColourWithPower", VALUEFUNC(_wrap_AutoParamDataSource_getLightDiffuseColourWithPower), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightSpecularColourWithPower", VALUEFUNC(_wrap_AutoParamDataSource_getLightSpecularColourWithPower), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightPosition", VALUEFUNC(_wrap_AutoParamDataSource_getLightPosition), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightAs4DVector", VALUEFUNC(_wrap_AutoParamDataSource_getLightAs4DVector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightDirection", VALUEFUNC(_wrap_AutoParamDataSource_getLightDirection), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightPowerScale", VALUEFUNC(_wrap_AutoParamDataSource_getLightPowerScale), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getLightAttenuation", VALUEFUNC(_wrap_AutoParamDataSource_getLightAttenuation), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSpotlightParams", VALUEFUNC(_wrap_AutoParamDataSource_getSpotlightParams), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setAmbientLightColour", VALUEFUNC(_wrap_AutoParamDataSource_setAmbientLightColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getAmbientLightColour", VALUEFUNC(_wrap_AutoParamDataSource_getAmbientLightColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSurfaceAmbientColour", VALUEFUNC(_wrap_AutoParamDataSource_getSurfaceAmbientColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSurfaceDiffuseColour", VALUEFUNC(_wrap_AutoParamDataSource_getSurfaceDiffuseColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSurfaceSpecularColour", VALUEFUNC(_wrap_AutoParamDataSource_getSurfaceSpecularColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSurfaceEmissiveColour", VALUEFUNC(_wrap_AutoParamDataSource_getSurfaceEmissiveColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSurfaceShininess", VALUEFUNC(_wrap_AutoParamDataSource_getSurfaceShininess), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getDerivedAmbientLightColour", VALUEFUNC(_wrap_AutoParamDataSource_getDerivedAmbientLightColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getDerivedSceneColour", VALUEFUNC(_wrap_AutoParamDataSource_getDerivedSceneColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setFog", VALUEFUNC(_wrap_AutoParamDataSource_setFog), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getFogColour", VALUEFUNC(_wrap_AutoParamDataSource_getFogColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getFogParams", VALUEFUNC(_wrap_AutoParamDataSource_getFogParams), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTextureViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTextureViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTextureWorldViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTextureWorldViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSpotlightViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getSpotlightViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSpotlightWorldViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getSpotlightWorldViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTextureTransformMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTextureTransformMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCurrentRenderTarget", VALUEFUNC(_wrap_AutoParamDataSource_getCurrentRenderTarget), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCurrentRenderable", VALUEFUNC(_wrap_AutoParamDataSource_getCurrentRenderable), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCurrentPass", VALUEFUNC(_wrap_AutoParamDataSource_getCurrentPass), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTextureSize", VALUEFUNC(_wrap_AutoParamDataSource_getTextureSize), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseTextureSize", VALUEFUNC(_wrap_AutoParamDataSource_getInverseTextureSize), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getPackedTextureSize", VALUEFUNC(_wrap_AutoParamDataSource_getPackedTextureSize), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getShadowExtrusionDistance", VALUEFUNC(_wrap_AutoParamDataSource_getShadowExtrusionDistance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSceneDepthRange", VALUEFUNC(_wrap_AutoParamDataSource_getSceneDepthRange), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getShadowSceneDepthRange", VALUEFUNC(_wrap_AutoParamDataSource_getShadowSceneDepthRange), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getShadowColour", VALUEFUNC(_wrap_AutoParamDataSource_getShadowColour), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseTransposeViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseTransposeViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTransposeViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTransposeViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTransposeViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTransposeViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseTransposeViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseTransposeViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTransposeProjectionMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTransposeProjectionMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseProjectionMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseProjectionMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseTransposeProjectionMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseTransposeProjectionMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTransposeWorldViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTransposeWorldViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseWorldViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseWorldViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseTransposeWorldViewProjMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getInverseTransposeWorldViewProjMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTransposeWorldViewMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTransposeWorldViewMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTransposeWorldMatrix", VALUEFUNC(_wrap_AutoParamDataSource_getTransposeWorldMatrix), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTime", VALUEFUNC(_wrap_AutoParamDataSource_getTime), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTime_0_X", VALUEFUNC(_wrap_AutoParamDataSource_getTime_0_X), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCosTime_0_X", VALUEFUNC(_wrap_AutoParamDataSource_getCosTime_0_X), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSinTime_0_X", VALUEFUNC(_wrap_AutoParamDataSource_getSinTime_0_X), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTanTime_0_X", VALUEFUNC(_wrap_AutoParamDataSource_getTanTime_0_X), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTime_0_X_packed", VALUEFUNC(_wrap_AutoParamDataSource_getTime_0_X_packed), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTime_0_1", VALUEFUNC(_wrap_AutoParamDataSource_getTime_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCosTime_0_1", VALUEFUNC(_wrap_AutoParamDataSource_getCosTime_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSinTime_0_1", VALUEFUNC(_wrap_AutoParamDataSource_getSinTime_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTanTime_0_1", VALUEFUNC(_wrap_AutoParamDataSource_getTanTime_0_1), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTime_0_1_packed", VALUEFUNC(_wrap_AutoParamDataSource_getTime_0_1_packed), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTime_0_2Pi", VALUEFUNC(_wrap_AutoParamDataSource_getTime_0_2Pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getCosTime_0_2Pi", VALUEFUNC(_wrap_AutoParamDataSource_getCosTime_0_2Pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getSinTime_0_2Pi", VALUEFUNC(_wrap_AutoParamDataSource_getSinTime_0_2Pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTanTime_0_2Pi", VALUEFUNC(_wrap_AutoParamDataSource_getTanTime_0_2Pi), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getTime_0_2Pi_packed", VALUEFUNC(_wrap_AutoParamDataSource_getTime_0_2Pi_packed), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getFrameTime", VALUEFUNC(_wrap_AutoParamDataSource_getFrameTime), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getFPS", VALUEFUNC(_wrap_AutoParamDataSource_getFPS), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getViewportWidth", VALUEFUNC(_wrap_AutoParamDataSource_getViewportWidth), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getViewportHeight", VALUEFUNC(_wrap_AutoParamDataSource_getViewportHeight), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseViewportWidth", VALUEFUNC(_wrap_AutoParamDataSource_getInverseViewportWidth), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getInverseViewportHeight", VALUEFUNC(_wrap_AutoParamDataSource_getInverseViewportHeight), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getViewDirection", VALUEFUNC(_wrap_AutoParamDataSource_getViewDirection), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getViewSideVector", VALUEFUNC(_wrap_AutoParamDataSource_getViewSideVector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getViewUpVector", VALUEFUNC(_wrap_AutoParamDataSource_getViewUpVector), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getFOV", VALUEFUNC(_wrap_AutoParamDataSource_getFOV), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getNearClipDistance", VALUEFUNC(_wrap_AutoParamDataSource_getNearClipDistance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getFarClipDistance", VALUEFUNC(_wrap_AutoParamDataSource_getFarClipDistance), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "getPassNumber", VALUEFUNC(_wrap_AutoParamDataSource_getPassNumber), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "setPassNumber", VALUEFUNC(_wrap_AutoParamDataSource_setPassNumber), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "incPassNumber", VALUEFUNC(_wrap_AutoParamDataSource_incPassNumber), -1);
  rb_define_method(SwigClassAutoParamDataSource.klass, "updateLightCustomGpuParameter", VALUEFUNC(_wrap_AutoParamDataSource_updateLightCustomGpuParameter), -1);
  SwigClassAutoParamDataSource.mark = 0;
  SwigClassAutoParamDataSource.destroy = (void (*)(void *)) free_Ogre_AutoParamDataSource;
  SwigClassAutoParamDataSource.trackObjects = 0;
  
  SwigClassBillboard.klass = rb_define_class_under(mOgre, "Billboard", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Billboard, (void *) &SwigClassBillboard);
  rb_define_alloc_func(SwigClassBillboard.klass, _wrap_Billboard_allocate);
  rb_define_method(SwigClassBillboard.klass, "initialize", VALUEFUNC(_wrap_new_Billboard), -1);
  rb_define_method(SwigClassBillboard.klass, "mPosition=", VALUEFUNC(_wrap_Billboard_mPosition_set), -1);
  rb_define_method(SwigClassBillboard.klass, "mPosition", VALUEFUNC(_wrap_Billboard_mPosition_get), -1);
  rb_define_method(SwigClassBillboard.klass, "mDirection=", VALUEFUNC(_wrap_Billboard_mDirection_set), -1);
  rb_define_method(SwigClassBillboard.klass, "mDirection", VALUEFUNC(_wrap_Billboard_mDirection_get), -1);
  rb_define_method(SwigClassBillboard.klass, "mParentSet=", VALUEFUNC(_wrap_Billboard_mParentSet_set), -1);
  rb_define_method(SwigClassBillboard.klass, "mParentSet", VALUEFUNC(_wrap_Billboard_mParentSet_get), -1);
  rb_define_method(SwigClassBillboard.klass, "mColour=", VALUEFUNC(_wrap_Billboard_mColour_set), -1);
  rb_define_method(SwigClassBillboard.klass, "mColour", VALUEFUNC(_wrap_Billboard_mColour_get), -1);
  rb_define_method(SwigClassBillboard.klass, "mRotation=", VALUEFUNC(_wrap_Billboard_mRotation_set), -1);
  rb_define_method(SwigClassBillboard.klass, "mRotation", VALUEFUNC(_wrap_Billboard_mRotation_get), -1);
  rb_define_method(SwigClassBillboard.klass, "getRotation", VALUEFUNC(_wrap_Billboard_getRotation), -1);
  rb_define_method(SwigClassBillboard.klass, "setRotation", VALUEFUNC(_wrap_Billboard_setRotation), -1);
  rb_define_method(SwigClassBillboard.klass, "setPosition", VALUEFUNC(_wrap_Billboard_setPosition), -1);
  rb_define_method(SwigClassBillboard.klass, "getPosition", VALUEFUNC(_wrap_Billboard_getPosition), -1);
  rb_define_method(SwigClassBillboard.klass, "setDimensions", VALUEFUNC(_wrap_Billboard_setDimensions), -1);
  rb_define_method(SwigClassBillboard.klass, "resetDimensions", VALUEFUNC(_wrap_Billboard_resetDimensions), -1);
  rb_define_method(SwigClassBillboard.klass, "setColour", VALUEFUNC(_wrap_Billboard_setColour), -1);
  rb_define_method(SwigClassBillboard.klass, "getColour", VALUEFUNC(_wrap_Billboard_getColour), -1);
  rb_define_method(SwigClassBillboard.klass, "hasOwnDimensions", VALUEFUNC(_wrap_Billboard_hasOwnDimensions), -1);
  rb_define_method(SwigClassBillboard.klass, "getOwnWidth", VALUEFUNC(_wrap_Billboard_getOwnWidth), -1);
  rb_define_method(SwigClassBillboard.klass, "getOwnHeight", VALUEFUNC(_wrap_Billboard_getOwnHeight), -1);
  rb_define_method(SwigClassBillboard.klass, "_notifyOwner", VALUEFUNC(_wrap_Billboard__notifyOwner), -1);
  rb_define_method(SwigClassBillboard.klass, "isUseTexcoordRect", VALUEFUNC(_wrap_Billboard_isUseTexcoordRect), -1);
  rb_define_method(SwigClassBillboard.klass, "setTexcoordIndex", VALUEFUNC(_wrap_Billboard_setTexcoordIndex), -1);
  rb_define_method(SwigClassBillboard.klass, "getTexcoordIndex", VALUEFUNC(_wrap_Billboard_getTexcoordIndex), -1);
  rb_define_method(SwigClassBillboard.klass, "setTexcoordRect", VALUEFUNC(_wrap_Billboard_setTexcoordRect), -1);
  rb_define_method(SwigClassBillboard.klass, "getTexcoordRect", VALUEFUNC(_wrap_Billboard_getTexcoordRect), -1);
  SwigClassBillboard.mark = 0;
  SwigClassBillboard.destroy = (void (*)(void *)) free_Ogre_Billboard;
  SwigClassBillboard.trackObjects = 0;
  
  SwigClassBillboardChain.klass = rb_define_class_under(mOgre, "BillboardChain", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BillboardChain, (void *) &SwigClassBillboardChain);
  rb_define_alloc_func(SwigClassBillboardChain.klass, _wrap_BillboardChain_allocate);
  rb_define_method(SwigClassBillboardChain.klass, "initialize", VALUEFUNC(_wrap_new_BillboardChain), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setMaxChainElements", VALUEFUNC(_wrap_BillboardChain_setMaxChainElements), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getMaxChainElements", VALUEFUNC(_wrap_BillboardChain_getMaxChainElements), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setNumberOfChains", VALUEFUNC(_wrap_BillboardChain_setNumberOfChains), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getNumberOfChains", VALUEFUNC(_wrap_BillboardChain_getNumberOfChains), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setUseTextureCoords", VALUEFUNC(_wrap_BillboardChain_setUseTextureCoords), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getUseTextureCoords", VALUEFUNC(_wrap_BillboardChain_getUseTextureCoords), -1);
  rb_define_const(SwigClassBillboardChain.klass, "TCD_U", SWIG_From_int(static_cast< int >(Ogre::BillboardChain::TCD_U)));
  rb_define_const(SwigClassBillboardChain.klass, "TCD_V", SWIG_From_int(static_cast< int >(Ogre::BillboardChain::TCD_V)));
  rb_define_method(SwigClassBillboardChain.klass, "setTextureCoordDirection", VALUEFUNC(_wrap_BillboardChain_setTextureCoordDirection), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getTextureCoordDirection", VALUEFUNC(_wrap_BillboardChain_getTextureCoordDirection), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setOtherTextureCoordRange", VALUEFUNC(_wrap_BillboardChain_setOtherTextureCoordRange), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getOtherTextureCoordRange", VALUEFUNC(_wrap_BillboardChain_getOtherTextureCoordRange), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setUseVertexColours", VALUEFUNC(_wrap_BillboardChain_setUseVertexColours), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getUseVertexColours", VALUEFUNC(_wrap_BillboardChain_getUseVertexColours), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setDynamic", VALUEFUNC(_wrap_BillboardChain_setDynamic), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getDynamic", VALUEFUNC(_wrap_BillboardChain_getDynamic), -1);
  rb_define_method(SwigClassBillboardChain.klass, "addChainElement", VALUEFUNC(_wrap_BillboardChain_addChainElement), -1);
  rb_define_method(SwigClassBillboardChain.klass, "removeChainElement", VALUEFUNC(_wrap_BillboardChain_removeChainElement), -1);
  rb_define_method(SwigClassBillboardChain.klass, "updateChainElement", VALUEFUNC(_wrap_BillboardChain_updateChainElement), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getChainElement", VALUEFUNC(_wrap_BillboardChain_getChainElement), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getNumChainElements", VALUEFUNC(_wrap_BillboardChain_getNumChainElements), -1);
  rb_define_method(SwigClassBillboardChain.klass, "clearChain", VALUEFUNC(_wrap_BillboardChain_clearChain), -1);
  rb_define_method(SwigClassBillboardChain.klass, "clearAllChains", VALUEFUNC(_wrap_BillboardChain_clearAllChains), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setFaceCamera", VALUEFUNC(_wrap_BillboardChain_setFaceCamera), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getMaterialName", VALUEFUNC(_wrap_BillboardChain_getMaterialName), -1);
  rb_define_method(SwigClassBillboardChain.klass, "setMaterialName", VALUEFUNC(_wrap_BillboardChain_setMaterialName), -1);
  rb_define_method(SwigClassBillboardChain.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_BillboardChain__notifyCurrentCamera), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_BillboardChain_getSquaredViewDepth), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getBoundingRadius", VALUEFUNC(_wrap_BillboardChain_getBoundingRadius), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getBoundingBox", VALUEFUNC(_wrap_BillboardChain_getBoundingBox), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getMaterial", VALUEFUNC(_wrap_BillboardChain_getMaterial), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getMovableType", VALUEFUNC(_wrap_BillboardChain_getMovableType), -1);
  rb_define_method(SwigClassBillboardChain.klass, "_updateRenderQueue", VALUEFUNC(_wrap_BillboardChain__updateRenderQueue), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getRenderOperation", VALUEFUNC(_wrap_BillboardChain_getRenderOperation), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getWorldTransforms", VALUEFUNC(_wrap_BillboardChain_getWorldTransforms), -1);
  rb_define_method(SwigClassBillboardChain.klass, "getLights", VALUEFUNC(_wrap_BillboardChain_getLights), -1);
  rb_define_method(SwigClassBillboardChain.klass, "visitRenderables", VALUEFUNC(_wrap_BillboardChain_visitRenderables), -1);
  SwigClassBillboardChain.mark = 0;
  SwigClassBillboardChain.destroy = (void (*)(void *)) free_Ogre_BillboardChain;
  SwigClassBillboardChain.trackObjects = 0;
  
  SwigClassBillboardChainFactory.klass = rb_define_class_under(mOgre, "BillboardChainFactory", ((swig_class *) SWIGTYPE_p_Ogre__MovableObjectFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BillboardChainFactory, (void *) &SwigClassBillboardChainFactory);
  rb_undef_alloc_func(SwigClassBillboardChainFactory.klass);
  rb_define_singleton_method(SwigClassBillboardChainFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_BillboardChainFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_singleton_method(SwigClassBillboardChainFactory.klass, "FACTORY_TYPE_NAME=", VALUEFUNC(_wrap_BillboardChainFactory_FACTORY_TYPE_NAME_set), 1);
  rb_define_method(SwigClassBillboardChainFactory.klass, "getType", VALUEFUNC(_wrap_BillboardChainFactory_getType), -1);
  rb_define_method(SwigClassBillboardChainFactory.klass, "destroyInstance", VALUEFUNC(_wrap_BillboardChainFactory_destroyInstance), -1);
  SwigClassBillboardChainFactory.mark = 0;
  SwigClassBillboardChainFactory.destroy = (void (*)(void *)) free_Ogre_BillboardChainFactory;
  SwigClassBillboardChainFactory.trackObjects = 0;
  
  SwigClassParticleSystemRenderer.klass = rb_define_class_under(mOgre, "ParticleSystemRenderer", ((swig_class *) SWIGTYPE_p_Ogre__StringInterface->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleSystemRenderer, (void *) &SwigClassParticleSystemRenderer);
  rb_undef_alloc_func(SwigClassParticleSystemRenderer.klass);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "getType", VALUEFUNC(_wrap_ParticleSystemRenderer_getType), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_updateRenderQueue", VALUEFUNC(_wrap_ParticleSystemRenderer__updateRenderQueue), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_setMaterial", VALUEFUNC(_wrap_ParticleSystemRenderer__setMaterial), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyCurrentCamera), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyAttached", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyAttached), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyParticleRotated", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyParticleRotated), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyParticleResized", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyParticleResized), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyParticleQuota", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyParticleQuota), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyDefaultDimensions", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyDefaultDimensions), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyParticleEmitted", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyParticleEmitted), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyParticleExpired", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyParticleExpired), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyParticleMoved", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyParticleMoved), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_notifyParticleCleared", VALUEFUNC(_wrap_ParticleSystemRenderer__notifyParticleCleared), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_createVisualData", VALUEFUNC(_wrap_ParticleSystemRenderer__createVisualData), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_destroyVisualData", VALUEFUNC(_wrap_ParticleSystemRenderer__destroyVisualData), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_ParticleSystemRenderer_setRenderQueueGroup), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "setKeepParticlesInLocalSpace", VALUEFUNC(_wrap_ParticleSystemRenderer_setKeepParticlesInLocalSpace), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "_getSortMode", VALUEFUNC(_wrap_ParticleSystemRenderer__getSortMode), -1);
  rb_define_method(SwigClassParticleSystemRenderer.klass, "visitRenderables", VALUEFUNC(_wrap_ParticleSystemRenderer_visitRenderables), -1);
  SwigClassParticleSystemRenderer.mark = 0;
  SwigClassParticleSystemRenderer.destroy = (void (*)(void *)) free_Ogre_ParticleSystemRenderer;
  SwigClassParticleSystemRenderer.trackObjects = 0;
  
  SwigClassParticleSystemRendererFactory.klass = rb_define_class_under(mOgre, "ParticleSystemRendererFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleSystemRendererFactory, (void *) &SwigClassParticleSystemRendererFactory);
  rb_undef_alloc_func(SwigClassParticleSystemRendererFactory.klass);
  SwigClassParticleSystemRendererFactory.mark = 0;
  SwigClassParticleSystemRendererFactory.destroy = (void (*)(void *)) free_Ogre_ParticleSystemRendererFactory;
  SwigClassParticleSystemRendererFactory.trackObjects = 0;
  rb_define_const(mOgre, "BBO_TOP_LEFT", SWIG_From_int(static_cast< int >(Ogre::BBO_TOP_LEFT)));
  rb_define_const(mOgre, "BBO_TOP_CENTER", SWIG_From_int(static_cast< int >(Ogre::BBO_TOP_CENTER)));
  rb_define_const(mOgre, "BBO_TOP_RIGHT", SWIG_From_int(static_cast< int >(Ogre::BBO_TOP_RIGHT)));
  rb_define_const(mOgre, "BBO_CENTER_LEFT", SWIG_From_int(static_cast< int >(Ogre::BBO_CENTER_LEFT)));
  rb_define_const(mOgre, "BBO_CENTER", SWIG_From_int(static_cast< int >(Ogre::BBO_CENTER)));
  rb_define_const(mOgre, "BBO_CENTER_RIGHT", SWIG_From_int(static_cast< int >(Ogre::BBO_CENTER_RIGHT)));
  rb_define_const(mOgre, "BBO_BOTTOM_LEFT", SWIG_From_int(static_cast< int >(Ogre::BBO_BOTTOM_LEFT)));
  rb_define_const(mOgre, "BBO_BOTTOM_CENTER", SWIG_From_int(static_cast< int >(Ogre::BBO_BOTTOM_CENTER)));
  rb_define_const(mOgre, "BBO_BOTTOM_RIGHT", SWIG_From_int(static_cast< int >(Ogre::BBO_BOTTOM_RIGHT)));
  rb_define_const(mOgre, "BBR_VERTEX", SWIG_From_int(static_cast< int >(Ogre::BBR_VERTEX)));
  rb_define_const(mOgre, "BBR_TEXCOORD", SWIG_From_int(static_cast< int >(Ogre::BBR_TEXCOORD)));
  rb_define_const(mOgre, "BBT_POINT", SWIG_From_int(static_cast< int >(Ogre::BBT_POINT)));
  rb_define_const(mOgre, "BBT_ORIENTED_COMMON", SWIG_From_int(static_cast< int >(Ogre::BBT_ORIENTED_COMMON)));
  rb_define_const(mOgre, "BBT_ORIENTED_SELF", SWIG_From_int(static_cast< int >(Ogre::BBT_ORIENTED_SELF)));
  rb_define_const(mOgre, "BBT_PERPENDICULAR_COMMON", SWIG_From_int(static_cast< int >(Ogre::BBT_PERPENDICULAR_COMMON)));
  rb_define_const(mOgre, "BBT_PERPENDICULAR_SELF", SWIG_From_int(static_cast< int >(Ogre::BBT_PERPENDICULAR_SELF)));
  
  SwigClassBillboardSet.klass = rb_define_class_under(mOgre, "BillboardSet", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BillboardSet, (void *) &SwigClassBillboardSet);
  rb_define_alloc_func(SwigClassBillboardSet.klass, _wrap_BillboardSet_allocate);
  rb_define_method(SwigClassBillboardSet.klass, "initialize", VALUEFUNC(_wrap_new_BillboardSet), -1);
  rb_define_method(SwigClassBillboardSet.klass, "createBillboard", VALUEFUNC(_wrap_BillboardSet_createBillboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getNumBillboards", VALUEFUNC(_wrap_BillboardSet_getNumBillboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setAutoextend", VALUEFUNC(_wrap_BillboardSet_setAutoextend), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getAutoextend", VALUEFUNC(_wrap_BillboardSet_getAutoextend), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setSortingEnabled", VALUEFUNC(_wrap_BillboardSet_setSortingEnabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getSortingEnabled", VALUEFUNC(_wrap_BillboardSet_getSortingEnabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setPoolSize", VALUEFUNC(_wrap_BillboardSet_setPoolSize), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getPoolSize", VALUEFUNC(_wrap_BillboardSet_getPoolSize), -1);
  rb_define_method(SwigClassBillboardSet.klass, "clear", VALUEFUNC(_wrap_BillboardSet_clear), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getBillboard", VALUEFUNC(_wrap_BillboardSet_getBillboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "removeBillboard", VALUEFUNC(_wrap_BillboardSet_removeBillboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setBillboardOrigin", VALUEFUNC(_wrap_BillboardSet_setBillboardOrigin), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getBillboardOrigin", VALUEFUNC(_wrap_BillboardSet_getBillboardOrigin), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setBillboardRotationType", VALUEFUNC(_wrap_BillboardSet_setBillboardRotationType), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getBillboardRotationType", VALUEFUNC(_wrap_BillboardSet_getBillboardRotationType), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setDefaultDimensions", VALUEFUNC(_wrap_BillboardSet_setDefaultDimensions), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setDefaultWidth", VALUEFUNC(_wrap_BillboardSet_setDefaultWidth), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getDefaultWidth", VALUEFUNC(_wrap_BillboardSet_getDefaultWidth), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setDefaultHeight", VALUEFUNC(_wrap_BillboardSet_setDefaultHeight), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getDefaultHeight", VALUEFUNC(_wrap_BillboardSet_getDefaultHeight), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setMaterialName", VALUEFUNC(_wrap_BillboardSet_setMaterialName), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getMaterialName", VALUEFUNC(_wrap_BillboardSet_getMaterialName), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_BillboardSet__notifyCurrentCamera), -1);
  rb_define_method(SwigClassBillboardSet.klass, "beginBillboards", VALUEFUNC(_wrap_BillboardSet_beginBillboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "injectBillboard", VALUEFUNC(_wrap_BillboardSet_injectBillboard), -1);
  rb_define_method(SwigClassBillboardSet.klass, "endBillboards", VALUEFUNC(_wrap_BillboardSet_endBillboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setBounds", VALUEFUNC(_wrap_BillboardSet_setBounds), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getBoundingBox", VALUEFUNC(_wrap_BillboardSet_getBoundingBox), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getBoundingRadius", VALUEFUNC(_wrap_BillboardSet_getBoundingRadius), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_updateRenderQueue", VALUEFUNC(_wrap_BillboardSet__updateRenderQueue), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getMaterial", VALUEFUNC(_wrap_BillboardSet_getMaterial), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setMaterial", VALUEFUNC(_wrap_BillboardSet_setMaterial), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getRenderOperation", VALUEFUNC(_wrap_BillboardSet_getRenderOperation), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getWorldTransforms", VALUEFUNC(_wrap_BillboardSet_getWorldTransforms), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_notifyBillboardResized", VALUEFUNC(_wrap_BillboardSet__notifyBillboardResized), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_notifyBillboardRotated", VALUEFUNC(_wrap_BillboardSet__notifyBillboardRotated), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getCullIndividually", VALUEFUNC(_wrap_BillboardSet_getCullIndividually), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setCullIndividually", VALUEFUNC(_wrap_BillboardSet_setCullIndividually), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setBillboardType", VALUEFUNC(_wrap_BillboardSet_setBillboardType), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getBillboardType", VALUEFUNC(_wrap_BillboardSet_getBillboardType), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setCommonDirection", VALUEFUNC(_wrap_BillboardSet_setCommonDirection), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getCommonDirection", VALUEFUNC(_wrap_BillboardSet_getCommonDirection), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setCommonUpVector", VALUEFUNC(_wrap_BillboardSet_setCommonUpVector), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getCommonUpVector", VALUEFUNC(_wrap_BillboardSet_getCommonUpVector), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setUseAccurateFacing", VALUEFUNC(_wrap_BillboardSet_setUseAccurateFacing), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getUseAccurateFacing", VALUEFUNC(_wrap_BillboardSet_getUseAccurateFacing), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getMovableType", VALUEFUNC(_wrap_BillboardSet_getMovableType), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_BillboardSet_getSquaredViewDepth), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_updateBounds", VALUEFUNC(_wrap_BillboardSet__updateBounds), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getLights", VALUEFUNC(_wrap_BillboardSet_getLights), -1);
  rb_define_method(SwigClassBillboardSet.klass, "visitRenderables", VALUEFUNC(_wrap_BillboardSet_visitRenderables), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_sortBillboards", VALUEFUNC(_wrap_BillboardSet__sortBillboards), -1);
  rb_define_method(SwigClassBillboardSet.klass, "_getSortMode", VALUEFUNC(_wrap_BillboardSet__getSortMode), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setBillboardsInWorldSpace", VALUEFUNC(_wrap_BillboardSet_setBillboardsInWorldSpace), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setTextureCoords", VALUEFUNC(_wrap_BillboardSet_setTextureCoords), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setTextureStacksAndSlices", VALUEFUNC(_wrap_BillboardSet_setTextureStacksAndSlices), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getTextureCoords", VALUEFUNC(_wrap_BillboardSet_getTextureCoords), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setPointRenderingEnabled", VALUEFUNC(_wrap_BillboardSet_setPointRenderingEnabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "isPointRenderingEnabled", VALUEFUNC(_wrap_BillboardSet_isPointRenderingEnabled), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getTypeFlags", VALUEFUNC(_wrap_BillboardSet_getTypeFlags), -1);
  rb_define_method(SwigClassBillboardSet.klass, "setAutoUpdate", VALUEFUNC(_wrap_BillboardSet_setAutoUpdate), -1);
  rb_define_method(SwigClassBillboardSet.klass, "getAutoUpdate", VALUEFUNC(_wrap_BillboardSet_getAutoUpdate), -1);
  rb_define_method(SwigClassBillboardSet.klass, "notifyBillboardDataChanged", VALUEFUNC(_wrap_BillboardSet_notifyBillboardDataChanged), -1);
  SwigClassBillboardSet.mark = 0;
  SwigClassBillboardSet.destroy = (void (*)(void *)) free_Ogre_BillboardSet;
  SwigClassBillboardSet.trackObjects = 0;
  
  SwigClassBillboardSetFactory.klass = rb_define_class_under(mOgre, "BillboardSetFactory", ((swig_class *) SWIGTYPE_p_Ogre__MovableObjectFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BillboardSetFactory, (void *) &SwigClassBillboardSetFactory);
  rb_undef_alloc_func(SwigClassBillboardSetFactory.klass);
  rb_define_singleton_method(SwigClassBillboardSetFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_BillboardSetFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_singleton_method(SwigClassBillboardSetFactory.klass, "FACTORY_TYPE_NAME=", VALUEFUNC(_wrap_BillboardSetFactory_FACTORY_TYPE_NAME_set), 1);
  rb_define_method(SwigClassBillboardSetFactory.klass, "getType", VALUEFUNC(_wrap_BillboardSetFactory_getType), -1);
  rb_define_method(SwigClassBillboardSetFactory.klass, "destroyInstance", VALUEFUNC(_wrap_BillboardSetFactory_destroyInstance), -1);
  SwigClassBillboardSetFactory.mark = 0;
  SwigClassBillboardSetFactory.destroy = (void (*)(void *)) free_Ogre_BillboardSetFactory;
  SwigClassBillboardSetFactory.trackObjects = 0;
  
  SwigClassBillboardParticleRenderer.klass = rb_define_class_under(mOgre, "BillboardParticleRenderer", ((swig_class *) SWIGTYPE_p_Ogre__ParticleSystemRenderer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BillboardParticleRenderer, (void *) &SwigClassBillboardParticleRenderer);
  rb_define_alloc_func(SwigClassBillboardParticleRenderer.klass, _wrap_BillboardParticleRenderer_allocate);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "initialize", VALUEFUNC(_wrap_new_BillboardParticleRenderer), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setBillboardType", VALUEFUNC(_wrap_BillboardParticleRenderer_setBillboardType), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getBillboardType", VALUEFUNC(_wrap_BillboardParticleRenderer_getBillboardType), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setUseAccurateFacing", VALUEFUNC(_wrap_BillboardParticleRenderer_setUseAccurateFacing), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getUseAccurateFacing", VALUEFUNC(_wrap_BillboardParticleRenderer_getUseAccurateFacing), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setBillboardOrigin", VALUEFUNC(_wrap_BillboardParticleRenderer_setBillboardOrigin), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getBillboardOrigin", VALUEFUNC(_wrap_BillboardParticleRenderer_getBillboardOrigin), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setBillboardRotationType", VALUEFUNC(_wrap_BillboardParticleRenderer_setBillboardRotationType), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getBillboardRotationType", VALUEFUNC(_wrap_BillboardParticleRenderer_getBillboardRotationType), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setCommonDirection", VALUEFUNC(_wrap_BillboardParticleRenderer_setCommonDirection), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getCommonDirection", VALUEFUNC(_wrap_BillboardParticleRenderer_getCommonDirection), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setCommonUpVector", VALUEFUNC(_wrap_BillboardParticleRenderer_setCommonUpVector), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getCommonUpVector", VALUEFUNC(_wrap_BillboardParticleRenderer_getCommonUpVector), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setPointRenderingEnabled", VALUEFUNC(_wrap_BillboardParticleRenderer_setPointRenderingEnabled), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "isPointRenderingEnabled", VALUEFUNC(_wrap_BillboardParticleRenderer_isPointRenderingEnabled), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getType", VALUEFUNC(_wrap_BillboardParticleRenderer_getType), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_updateRenderQueue", VALUEFUNC(_wrap_BillboardParticleRenderer__updateRenderQueue), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "visitRenderables", VALUEFUNC(_wrap_BillboardParticleRenderer_visitRenderables), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_setMaterial", VALUEFUNC(_wrap_BillboardParticleRenderer__setMaterial), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_BillboardParticleRenderer__notifyCurrentCamera), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notifyParticleRotated", VALUEFUNC(_wrap_BillboardParticleRenderer__notifyParticleRotated), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notifyParticleResized", VALUEFUNC(_wrap_BillboardParticleRenderer__notifyParticleResized), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notifyParticleQuota", VALUEFUNC(_wrap_BillboardParticleRenderer__notifyParticleQuota), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notifyAttached", VALUEFUNC(_wrap_BillboardParticleRenderer__notifyAttached), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_notifyDefaultDimensions", VALUEFUNC(_wrap_BillboardParticleRenderer__notifyDefaultDimensions), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_BillboardParticleRenderer_setRenderQueueGroup), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "setKeepParticlesInLocalSpace", VALUEFUNC(_wrap_BillboardParticleRenderer_setKeepParticlesInLocalSpace), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "_getSortMode", VALUEFUNC(_wrap_BillboardParticleRenderer__getSortMode), -1);
  rb_define_method(SwigClassBillboardParticleRenderer.klass, "getBillboardSet", VALUEFUNC(_wrap_BillboardParticleRenderer_getBillboardSet), -1);
  SwigClassBillboardParticleRenderer.mark = 0;
  SwigClassBillboardParticleRenderer.destroy = (void (*)(void *)) free_Ogre_BillboardParticleRenderer;
  SwigClassBillboardParticleRenderer.trackObjects = 0;
  
  SwigClassBillboardParticleRendererFactory.klass = rb_define_class_under(mOgre, "BillboardParticleRendererFactory", ((swig_class *) SWIGTYPE_p_Ogre__ParticleSystemRendererFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BillboardParticleRendererFactory, (void *) &SwigClassBillboardParticleRendererFactory);
  rb_define_alloc_func(SwigClassBillboardParticleRendererFactory.klass, _wrap_BillboardParticleRendererFactory_allocate);
  rb_define_method(SwigClassBillboardParticleRendererFactory.klass, "initialize", VALUEFUNC(_wrap_new_BillboardParticleRendererFactory), -1);
  rb_define_method(SwigClassBillboardParticleRendererFactory.klass, "getType", VALUEFUNC(_wrap_BillboardParticleRendererFactory_getType), -1);
  rb_define_method(SwigClassBillboardParticleRendererFactory.klass, "createInstance", VALUEFUNC(_wrap_BillboardParticleRendererFactory_createInstance), -1);
  rb_define_method(SwigClassBillboardParticleRendererFactory.klass, "destroyInstance", VALUEFUNC(_wrap_BillboardParticleRendererFactory_destroyInstance), -1);
  SwigClassBillboardParticleRendererFactory.mark = 0;
  SwigClassBillboardParticleRendererFactory.destroy = (void (*)(void *)) free_Ogre_BillboardParticleRendererFactory;
  SwigClassBillboardParticleRendererFactory.trackObjects = 0;
  
  SwigClassBitwise.klass = rb_define_class_under(mOgre, "Bitwise", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Bitwise, (void *) &SwigClassBitwise);
  rb_define_alloc_func(SwigClassBitwise.klass, _wrap_Bitwise_allocate);
  rb_define_method(SwigClassBitwise.klass, "initialize", VALUEFUNC(_wrap_new_Bitwise), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "mostSignificantBitSet", VALUEFUNC(_wrap_Bitwise_mostSignificantBitSet), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "firstPO2From", VALUEFUNC(_wrap_Bitwise_firstPO2From), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "fixedToFixed", VALUEFUNC(_wrap_Bitwise_fixedToFixed), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "floatToFixed", VALUEFUNC(_wrap_Bitwise_floatToFixed), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "fixedToFloat", VALUEFUNC(_wrap_Bitwise_fixedToFloat), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "intWrite", VALUEFUNC(_wrap_Bitwise_intWrite), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "intRead", VALUEFUNC(_wrap_Bitwise_intRead), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "floatToHalf", VALUEFUNC(_wrap_Bitwise_floatToHalf), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "floatToHalfI", VALUEFUNC(_wrap_Bitwise_floatToHalfI), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "halfToFloat", VALUEFUNC(_wrap_Bitwise_halfToFloat), -1);
  rb_define_singleton_method(SwigClassBitwise.klass, "halfToFloatI", VALUEFUNC(_wrap_Bitwise_halfToFloatI), -1);
  SwigClassBitwise.mark = 0;
  SwigClassBitwise.destroy = (void (*)(void *)) free_Ogre_Bitwise;
  SwigClassBitwise.trackObjects = 0;
  rb_define_const(mOgre, "ANIMBLEND_AVERAGE", SWIG_From_int(static_cast< int >(Ogre::ANIMBLEND_AVERAGE)));
  rb_define_const(mOgre, "ANIMBLEND_CUMULATIVE", SWIG_From_int(static_cast< int >(Ogre::ANIMBLEND_CUMULATIVE)));
  rb_define_const(mOgre, "OGRE_MAX_NUM_BONES", SWIG_From_int(static_cast< int >(256)));
  
  SwigClassSkeleton.klass = rb_define_class_under(mOgre, "Skeleton", ((swig_class *) SWIGTYPE_p_Ogre__Resource->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Skeleton, (void *) &SwigClassSkeleton);
  rb_define_alloc_func(SwigClassSkeleton.klass, _wrap_Skeleton_allocate);
  rb_define_method(SwigClassSkeleton.klass, "initialize", VALUEFUNC(_wrap_new_Skeleton), -1);
  rb_define_method(SwigClassSkeleton.klass, "createBone", VALUEFUNC(_wrap_Skeleton_createBone), -1);
  rb_define_method(SwigClassSkeleton.klass, "getNumBones", VALUEFUNC(_wrap_Skeleton_getNumBones), -1);
  rb_define_method(SwigClassSkeleton.klass, "getRootBone", VALUEFUNC(_wrap_Skeleton_getRootBone), -1);
  rb_define_method(SwigClassSkeleton.klass, "getRootBoneIterator", VALUEFUNC(_wrap_Skeleton_getRootBoneIterator), -1);
  rb_define_method(SwigClassSkeleton.klass, "getBoneIterator", VALUEFUNC(_wrap_Skeleton_getBoneIterator), -1);
  rb_define_method(SwigClassSkeleton.klass, "getBone", VALUEFUNC(_wrap_Skeleton_getBone), -1);
  rb_define_method(SwigClassSkeleton.klass, "hasBone", VALUEFUNC(_wrap_Skeleton_hasBone), -1);
  rb_define_method(SwigClassSkeleton.klass, "setBindingPose", VALUEFUNC(_wrap_Skeleton_setBindingPose), -1);
  rb_define_method(SwigClassSkeleton.klass, "reset", VALUEFUNC(_wrap_Skeleton_reset), -1);
  rb_define_method(SwigClassSkeleton.klass, "createAnimation", VALUEFUNC(_wrap_Skeleton_createAnimation), -1);
  rb_define_method(SwigClassSkeleton.klass, "_getAnimationImpl", VALUEFUNC(_wrap_Skeleton__getAnimationImpl), -1);
  rb_define_method(SwigClassSkeleton.klass, "hasAnimation", VALUEFUNC(_wrap_Skeleton_hasAnimation), -1);
  rb_define_method(SwigClassSkeleton.klass, "removeAnimation", VALUEFUNC(_wrap_Skeleton_removeAnimation), -1);
  rb_define_method(SwigClassSkeleton.klass, "setAnimationState", VALUEFUNC(_wrap_Skeleton_setAnimationState), -1);
  rb_define_method(SwigClassSkeleton.klass, "_initAnimationState", VALUEFUNC(_wrap_Skeleton__initAnimationState), -1);
  rb_define_method(SwigClassSkeleton.klass, "_refreshAnimationState", VALUEFUNC(_wrap_Skeleton__refreshAnimationState), -1);
  rb_define_method(SwigClassSkeleton.klass, "_getBoneMatrices", VALUEFUNC(_wrap_Skeleton__getBoneMatrices), -1);
  rb_define_method(SwigClassSkeleton.klass, "getNumAnimations", VALUEFUNC(_wrap_Skeleton_getNumAnimations), -1);
  rb_define_method(SwigClassSkeleton.klass, "getAnimation", VALUEFUNC(_wrap_Skeleton_getAnimation), -1);
  rb_define_method(SwigClassSkeleton.klass, "getBlendMode", VALUEFUNC(_wrap_Skeleton_getBlendMode), -1);
  rb_define_method(SwigClassSkeleton.klass, "setBlendMode", VALUEFUNC(_wrap_Skeleton_setBlendMode), -1);
  rb_define_method(SwigClassSkeleton.klass, "_updateTransforms", VALUEFUNC(_wrap_Skeleton__updateTransforms), -1);
  rb_define_method(SwigClassSkeleton.klass, "optimiseAllAnimations", VALUEFUNC(_wrap_Skeleton_optimiseAllAnimations), -1);
  rb_define_method(SwigClassSkeleton.klass, "addLinkedSkeletonAnimationSource", VALUEFUNC(_wrap_Skeleton_addLinkedSkeletonAnimationSource), -1);
  rb_define_method(SwigClassSkeleton.klass, "removeAllLinkedSkeletonAnimationSources", VALUEFUNC(_wrap_Skeleton_removeAllLinkedSkeletonAnimationSources), -1);
  rb_define_method(SwigClassSkeleton.klass, "getLinkedSkeletonAnimationSourceIterator", VALUEFUNC(_wrap_Skeleton_getLinkedSkeletonAnimationSourceIterator), -1);
  rb_define_method(SwigClassSkeleton.klass, "_notifyManualBonesDirty", VALUEFUNC(_wrap_Skeleton__notifyManualBonesDirty), -1);
  rb_define_method(SwigClassSkeleton.klass, "_notifyManualBoneStateChange", VALUEFUNC(_wrap_Skeleton__notifyManualBoneStateChange), -1);
  rb_define_method(SwigClassSkeleton.klass, "getManualBonesDirty", VALUEFUNC(_wrap_Skeleton_getManualBonesDirty), -1);
  rb_define_method(SwigClassSkeleton.klass, "hasManualBones", VALUEFUNC(_wrap_Skeleton_hasManualBones), -1);
  rb_define_method(SwigClassSkeleton.klass, "_mergeSkeletonAnimations", VALUEFUNC(_wrap_Skeleton__mergeSkeletonAnimations), -1);
  rb_define_method(SwigClassSkeleton.klass, "_buildMapBoneByHandle", VALUEFUNC(_wrap_Skeleton__buildMapBoneByHandle), -1);
  rb_define_method(SwigClassSkeleton.klass, "_buildMapBoneByName", VALUEFUNC(_wrap_Skeleton__buildMapBoneByName), -1);
  SwigClassSkeleton.mark = 0;
  SwigClassSkeleton.destroy = (void (*)(void *)) free_Ogre_Skeleton;
  SwigClassSkeleton.trackObjects = 0;
  
  SwigClassSkeletonPtr.klass = rb_define_class_under(mOgre, "SkeletonPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SkeletonPtr, (void *) &SwigClassSkeletonPtr);
  rb_define_alloc_func(SwigClassSkeletonPtr.klass, _wrap_SkeletonPtr_allocate);
  rb_define_method(SwigClassSkeletonPtr.klass, "initialize", VALUEFUNC(_wrap_new_SkeletonPtr), -1);
  SwigClassSkeletonPtr.mark = 0;
  SwigClassSkeletonPtr.destroy = (void (*)(void *)) free_Ogre_SkeletonPtr;
  SwigClassSkeletonPtr.trackObjects = 0;
  
  SwigClassLinkedSkeletonAnimationSource.klass = rb_define_class_under(mOgre, "LinkedSkeletonAnimationSource", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LinkedSkeletonAnimationSource, (void *) &SwigClassLinkedSkeletonAnimationSource);
  rb_define_alloc_func(SwigClassLinkedSkeletonAnimationSource.klass, _wrap_LinkedSkeletonAnimationSource_allocate);
  rb_define_method(SwigClassLinkedSkeletonAnimationSource.klass, "initialize", VALUEFUNC(_wrap_new_LinkedSkeletonAnimationSource), -1);
  rb_define_method(SwigClassLinkedSkeletonAnimationSource.klass, "skeletonName=", VALUEFUNC(_wrap_LinkedSkeletonAnimationSource_skeletonName_set), -1);
  rb_define_method(SwigClassLinkedSkeletonAnimationSource.klass, "skeletonName", VALUEFUNC(_wrap_LinkedSkeletonAnimationSource_skeletonName_get), -1);
  rb_define_method(SwigClassLinkedSkeletonAnimationSource.klass, "pSkeleton=", VALUEFUNC(_wrap_LinkedSkeletonAnimationSource_pSkeleton_set), -1);
  rb_define_method(SwigClassLinkedSkeletonAnimationSource.klass, "pSkeleton", VALUEFUNC(_wrap_LinkedSkeletonAnimationSource_pSkeleton_get), -1);
  rb_define_method(SwigClassLinkedSkeletonAnimationSource.klass, "scale=", VALUEFUNC(_wrap_LinkedSkeletonAnimationSource_scale_set), -1);
  rb_define_method(SwigClassLinkedSkeletonAnimationSource.klass, "scale", VALUEFUNC(_wrap_LinkedSkeletonAnimationSource_scale_get), -1);
  SwigClassLinkedSkeletonAnimationSource.mark = 0;
  SwigClassLinkedSkeletonAnimationSource.destroy = (void (*)(void *)) free_Ogre_LinkedSkeletonAnimationSource;
  SwigClassLinkedSkeletonAnimationSource.trackObjects = 0;
  
  SwigClassMeshSharedPtr.klass = rb_define_class_under(mOgre, "MeshSharedPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t, (void *) &SwigClassMeshSharedPtr);
  rb_define_alloc_func(SwigClassMeshSharedPtr.klass, _wrap_MeshSharedPtr_allocate);
  rb_define_method(SwigClassMeshSharedPtr.klass, "initialize", VALUEFUNC(_wrap_new_MeshSharedPtr), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "__ref__", VALUEFUNC(_wrap_MeshSharedPtr___ref__), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "__deref__", VALUEFUNC(_wrap_MeshSharedPtr___deref__), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "get", VALUEFUNC(_wrap_MeshSharedPtr_get), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "bind", VALUEFUNC(_wrap_MeshSharedPtr_bind), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "unique", VALUEFUNC(_wrap_MeshSharedPtr_unique), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "useCount", VALUEFUNC(_wrap_MeshSharedPtr_useCount), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "useCountPointer", VALUEFUNC(_wrap_MeshSharedPtr_useCountPointer), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getPointer", VALUEFUNC(_wrap_MeshSharedPtr_getPointer), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "freeMethod", VALUEFUNC(_wrap_MeshSharedPtr_freeMethod), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isNull", VALUEFUNC(_wrap_MeshSharedPtr_isNull), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setNull", VALUEFUNC(_wrap_MeshSharedPtr_setNull), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "createSubMesh", VALUEFUNC(_wrap_MeshSharedPtr_createSubMesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "nameSubMesh", VALUEFUNC(_wrap_MeshSharedPtr_nameSubMesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "unnameSubMesh", VALUEFUNC(_wrap_MeshSharedPtr_unnameSubMesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_getSubMeshIndex", VALUEFUNC(_wrap_MeshSharedPtr__getSubMeshIndex), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getNumSubMeshes", VALUEFUNC(_wrap_MeshSharedPtr_getNumSubMeshes), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSubMesh", VALUEFUNC(_wrap_MeshSharedPtr_getSubMesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "destroySubMesh", VALUEFUNC(_wrap_MeshSharedPtr_destroySubMesh), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSubMeshIterator", VALUEFUNC(_wrap_MeshSharedPtr_getSubMeshIterator), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "sharedVertexData=", VALUEFUNC(_wrap_MeshSharedPtr_sharedVertexData_set), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "sharedVertexData", VALUEFUNC(_wrap_MeshSharedPtr_sharedVertexData_get), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "sharedBlendIndexToBoneIndexMap=", VALUEFUNC(_wrap_MeshSharedPtr_sharedBlendIndexToBoneIndexMap_set), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "sharedBlendIndexToBoneIndexMap", VALUEFUNC(_wrap_MeshSharedPtr_sharedBlendIndexToBoneIndexMap_get), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "clone", VALUEFUNC(_wrap_MeshSharedPtr_clone), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getBounds", VALUEFUNC(_wrap_MeshSharedPtr_getBounds), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getBoundingSphereRadius", VALUEFUNC(_wrap_MeshSharedPtr_getBoundingSphereRadius), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_setBounds", VALUEFUNC(_wrap_MeshSharedPtr__setBounds), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_setBoundingSphereRadius", VALUEFUNC(_wrap_MeshSharedPtr__setBoundingSphereRadius), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setSkeletonName", VALUEFUNC(_wrap_MeshSharedPtr_setSkeletonName), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "hasSkeleton", VALUEFUNC(_wrap_MeshSharedPtr_hasSkeleton), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "hasVertexAnimation", VALUEFUNC(_wrap_MeshSharedPtr_hasVertexAnimation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSkeleton", VALUEFUNC(_wrap_MeshSharedPtr_getSkeleton), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSkeletonName", VALUEFUNC(_wrap_MeshSharedPtr_getSkeletonName), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_initAnimationState", VALUEFUNC(_wrap_MeshSharedPtr__initAnimationState), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_refreshAnimationState", VALUEFUNC(_wrap_MeshSharedPtr__refreshAnimationState), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "addBoneAssignment", VALUEFUNC(_wrap_MeshSharedPtr_addBoneAssignment), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "clearBoneAssignments", VALUEFUNC(_wrap_MeshSharedPtr_clearBoneAssignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_notifySkeleton", VALUEFUNC(_wrap_MeshSharedPtr__notifySkeleton), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getBoneAssignmentIterator", VALUEFUNC(_wrap_MeshSharedPtr_getBoneAssignmentIterator), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getBoneAssignments", VALUEFUNC(_wrap_MeshSharedPtr_getBoneAssignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getNumLodLevels", VALUEFUNC(_wrap_MeshSharedPtr_getNumLodLevels), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getLodLevel", VALUEFUNC(_wrap_MeshSharedPtr_getLodLevel), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "createManualLodLevel", VALUEFUNC(_wrap_MeshSharedPtr_createManualLodLevel), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "updateManualLodLevel", VALUEFUNC(_wrap_MeshSharedPtr_updateManualLodLevel), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getLodIndex", VALUEFUNC(_wrap_MeshSharedPtr_getLodIndex), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isLodManual", VALUEFUNC(_wrap_MeshSharedPtr_isLodManual), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_setLodInfo", VALUEFUNC(_wrap_MeshSharedPtr__setLodInfo), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_setLodUsage", VALUEFUNC(_wrap_MeshSharedPtr__setLodUsage), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_setSubMeshLodFaceList", VALUEFUNC(_wrap_MeshSharedPtr__setSubMeshLodFaceList), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "removeLodLevels", VALUEFUNC(_wrap_MeshSharedPtr_removeLodLevels), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setVertexBufferPolicy", VALUEFUNC(_wrap_MeshSharedPtr_setVertexBufferPolicy), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setIndexBufferPolicy", VALUEFUNC(_wrap_MeshSharedPtr_setIndexBufferPolicy), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getVertexBufferUsage", VALUEFUNC(_wrap_MeshSharedPtr_getVertexBufferUsage), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getIndexBufferUsage", VALUEFUNC(_wrap_MeshSharedPtr_getIndexBufferUsage), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isVertexBufferShadowed", VALUEFUNC(_wrap_MeshSharedPtr_isVertexBufferShadowed), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isIndexBufferShadowed", VALUEFUNC(_wrap_MeshSharedPtr_isIndexBufferShadowed), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_rationaliseBoneAssignments", VALUEFUNC(_wrap_MeshSharedPtr__rationaliseBoneAssignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_compileBoneAssignments", VALUEFUNC(_wrap_MeshSharedPtr__compileBoneAssignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_updateCompiledBoneAssignments", VALUEFUNC(_wrap_MeshSharedPtr__updateCompiledBoneAssignments), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "buildTangentVectors", VALUEFUNC(_wrap_MeshSharedPtr_buildTangentVectors), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "suggestTangentVectorBuildParams", VALUEFUNC(_wrap_MeshSharedPtr_suggestTangentVectorBuildParams), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "buildEdgeList", VALUEFUNC(_wrap_MeshSharedPtr_buildEdgeList), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "freeEdgeList", VALUEFUNC(_wrap_MeshSharedPtr_freeEdgeList), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "prepareForShadowVolume", VALUEFUNC(_wrap_MeshSharedPtr_prepareForShadowVolume), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getEdgeList", VALUEFUNC(_wrap_MeshSharedPtr_getEdgeList), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isPreparedForShadowVolumes", VALUEFUNC(_wrap_MeshSharedPtr_isPreparedForShadowVolumes), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isEdgeListBuilt", VALUEFUNC(_wrap_MeshSharedPtr_isEdgeListBuilt), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "prepareMatricesForVertexBlend", VALUEFUNC(_wrap_MeshSharedPtr_prepareMatricesForVertexBlend), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "softwareVertexBlend", VALUEFUNC(_wrap_MeshSharedPtr_softwareVertexBlend), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "softwareVertexMorph", VALUEFUNC(_wrap_MeshSharedPtr_softwareVertexMorph), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "softwareVertexPoseBlend", VALUEFUNC(_wrap_MeshSharedPtr_softwareVertexPoseBlend), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSubMeshNameMap", VALUEFUNC(_wrap_MeshSharedPtr_getSubMeshNameMap), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setAutoBuildEdgeLists", VALUEFUNC(_wrap_MeshSharedPtr_setAutoBuildEdgeLists), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getAutoBuildEdgeLists", VALUEFUNC(_wrap_MeshSharedPtr_getAutoBuildEdgeLists), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSharedVertexDataAnimationType", VALUEFUNC(_wrap_MeshSharedPtr_getSharedVertexDataAnimationType), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSharedVertexDataAnimationIncludesNormals", VALUEFUNC(_wrap_MeshSharedPtr_getSharedVertexDataAnimationIncludesNormals), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "createAnimation", VALUEFUNC(_wrap_MeshSharedPtr_createAnimation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getAnimation", VALUEFUNC(_wrap_MeshSharedPtr_getAnimation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_getAnimationImpl", VALUEFUNC(_wrap_MeshSharedPtr__getAnimationImpl), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "hasAnimation", VALUEFUNC(_wrap_MeshSharedPtr_hasAnimation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "removeAnimation", VALUEFUNC(_wrap_MeshSharedPtr_removeAnimation), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getNumAnimations", VALUEFUNC(_wrap_MeshSharedPtr_getNumAnimations), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "removeAllAnimations", VALUEFUNC(_wrap_MeshSharedPtr_removeAllAnimations), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getVertexDataByTrackHandle", VALUEFUNC(_wrap_MeshSharedPtr_getVertexDataByTrackHandle), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "updateMaterialForAllSubMeshes", VALUEFUNC(_wrap_MeshSharedPtr_updateMaterialForAllSubMeshes), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_determineAnimationTypes", VALUEFUNC(_wrap_MeshSharedPtr__determineAnimationTypes), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_getAnimationTypesDirty", VALUEFUNC(_wrap_MeshSharedPtr__getAnimationTypesDirty), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "createPose", VALUEFUNC(_wrap_MeshSharedPtr_createPose), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getPoseCount", VALUEFUNC(_wrap_MeshSharedPtr_getPoseCount), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getPose", VALUEFUNC(_wrap_MeshSharedPtr_getPose), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "removePose", VALUEFUNC(_wrap_MeshSharedPtr_removePose), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "removeAllPoses", VALUEFUNC(_wrap_MeshSharedPtr_removeAllPoses), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getPoseList", VALUEFUNC(_wrap_MeshSharedPtr_getPoseList), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getLodStrategy", VALUEFUNC(_wrap_MeshSharedPtr_getLodStrategy), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setLodStrategy", VALUEFUNC(_wrap_MeshSharedPtr_setLodStrategy), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "prepare", VALUEFUNC(_wrap_MeshSharedPtr_prepare), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "load", VALUEFUNC(_wrap_MeshSharedPtr_load), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "reload", VALUEFUNC(_wrap_MeshSharedPtr_reload), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isReloadable", VALUEFUNC(_wrap_MeshSharedPtr_isReloadable), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isManuallyLoaded", VALUEFUNC(_wrap_MeshSharedPtr_isManuallyLoaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "unload", VALUEFUNC(_wrap_MeshSharedPtr_unload), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getSize", VALUEFUNC(_wrap_MeshSharedPtr_getSize), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "touch", VALUEFUNC(_wrap_MeshSharedPtr_touch), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getName", VALUEFUNC(_wrap_MeshSharedPtr_getName), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getHandle", VALUEFUNC(_wrap_MeshSharedPtr_getHandle), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isPrepared", VALUEFUNC(_wrap_MeshSharedPtr_isPrepared), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isLoaded", VALUEFUNC(_wrap_MeshSharedPtr_isLoaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isLoading", VALUEFUNC(_wrap_MeshSharedPtr_isLoading), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getLoadingState", VALUEFUNC(_wrap_MeshSharedPtr_getLoadingState), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "isBackgroundLoaded", VALUEFUNC(_wrap_MeshSharedPtr_isBackgroundLoaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setBackgroundLoaded", VALUEFUNC(_wrap_MeshSharedPtr_setBackgroundLoaded), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "escalateLoading", VALUEFUNC(_wrap_MeshSharedPtr_escalateLoading), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "addListener", VALUEFUNC(_wrap_MeshSharedPtr_addListener), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "removeListener", VALUEFUNC(_wrap_MeshSharedPtr_removeListener), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getGroup", VALUEFUNC(_wrap_MeshSharedPtr_getGroup), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "changeGroupOwnership", VALUEFUNC(_wrap_MeshSharedPtr_changeGroupOwnership), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getCreator", VALUEFUNC(_wrap_MeshSharedPtr_getCreator), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getOrigin", VALUEFUNC(_wrap_MeshSharedPtr_getOrigin), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_notifyOrigin", VALUEFUNC(_wrap_MeshSharedPtr__notifyOrigin), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getStateCount", VALUEFUNC(_wrap_MeshSharedPtr_getStateCount), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_dirtyState", VALUEFUNC(_wrap_MeshSharedPtr__dirtyState), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_fireLoadingComplete", VALUEFUNC(_wrap_MeshSharedPtr__fireLoadingComplete), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_firePreparingComplete", VALUEFUNC(_wrap_MeshSharedPtr__firePreparingComplete), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "_fireUnloadingComplete", VALUEFUNC(_wrap_MeshSharedPtr__fireUnloadingComplete), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getParamDictionary", VALUEFUNC(_wrap_MeshSharedPtr_getParamDictionary), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getParameters", VALUEFUNC(_wrap_MeshSharedPtr_getParameters), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setParameter", VALUEFUNC(_wrap_MeshSharedPtr_setParameter), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "setParameterList", VALUEFUNC(_wrap_MeshSharedPtr_setParameterList), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "getParameter", VALUEFUNC(_wrap_MeshSharedPtr_getParameter), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "copyParametersTo", VALUEFUNC(_wrap_MeshSharedPtr_copyParametersTo), -1);
  rb_define_method(SwigClassMeshSharedPtr.klass, "cleanupDictionary", VALUEFUNC(_wrap_MeshSharedPtr_cleanupDictionary), -1);
  SwigClassMeshSharedPtr.mark = 0;
  SwigClassMeshSharedPtr.destroy = (void (*)(void *)) free_Ogre_SharedPtr_Sl_Ogre_Mesh_Sg_;
  SwigClassMeshSharedPtr.trackObjects = 0;
  
  SwigClassMesh.klass = rb_define_class_under(mOgre, "Mesh", ((swig_class *) SWIGTYPE_p_Ogre__Resource->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Mesh, (void *) &SwigClassMesh);
  rb_define_alloc_func(SwigClassMesh.klass, _wrap_Mesh_allocate);
  rb_define_method(SwigClassMesh.klass, "initialize", VALUEFUNC(_wrap_new_Mesh), -1);
  rb_define_method(SwigClassMesh.klass, "createSubMesh", VALUEFUNC(_wrap_Mesh_createSubMesh), -1);
  rb_define_method(SwigClassMesh.klass, "nameSubMesh", VALUEFUNC(_wrap_Mesh_nameSubMesh), -1);
  rb_define_method(SwigClassMesh.klass, "unnameSubMesh", VALUEFUNC(_wrap_Mesh_unnameSubMesh), -1);
  rb_define_method(SwigClassMesh.klass, "_getSubMeshIndex", VALUEFUNC(_wrap_Mesh__getSubMeshIndex), -1);
  rb_define_method(SwigClassMesh.klass, "getNumSubMeshes", VALUEFUNC(_wrap_Mesh_getNumSubMeshes), -1);
  rb_define_method(SwigClassMesh.klass, "getSubMesh", VALUEFUNC(_wrap_Mesh_getSubMesh), -1);
  rb_define_method(SwigClassMesh.klass, "destroySubMesh", VALUEFUNC(_wrap_Mesh_destroySubMesh), -1);
  rb_define_method(SwigClassMesh.klass, "getSubMeshIterator", VALUEFUNC(_wrap_Mesh_getSubMeshIterator), -1);
  rb_define_method(SwigClassMesh.klass, "sharedVertexData=", VALUEFUNC(_wrap_Mesh_sharedVertexData_set), -1);
  rb_define_method(SwigClassMesh.klass, "sharedVertexData", VALUEFUNC(_wrap_Mesh_sharedVertexData_get), -1);
  rb_define_method(SwigClassMesh.klass, "sharedBlendIndexToBoneIndexMap=", VALUEFUNC(_wrap_Mesh_sharedBlendIndexToBoneIndexMap_set), -1);
  rb_define_method(SwigClassMesh.klass, "sharedBlendIndexToBoneIndexMap", VALUEFUNC(_wrap_Mesh_sharedBlendIndexToBoneIndexMap_get), -1);
  rb_define_method(SwigClassMesh.klass, "clone", VALUEFUNC(_wrap_Mesh_clone), -1);
  rb_define_method(SwigClassMesh.klass, "getBounds", VALUEFUNC(_wrap_Mesh_getBounds), -1);
  rb_define_method(SwigClassMesh.klass, "getBoundingSphereRadius", VALUEFUNC(_wrap_Mesh_getBoundingSphereRadius), -1);
  rb_define_method(SwigClassMesh.klass, "_setBounds", VALUEFUNC(_wrap_Mesh__setBounds), -1);
  rb_define_method(SwigClassMesh.klass, "_setBoundingSphereRadius", VALUEFUNC(_wrap_Mesh__setBoundingSphereRadius), -1);
  rb_define_method(SwigClassMesh.klass, "setSkeletonName", VALUEFUNC(_wrap_Mesh_setSkeletonName), -1);
  rb_define_method(SwigClassMesh.klass, "hasSkeleton", VALUEFUNC(_wrap_Mesh_hasSkeleton), -1);
  rb_define_method(SwigClassMesh.klass, "hasVertexAnimation", VALUEFUNC(_wrap_Mesh_hasVertexAnimation), -1);
  rb_define_method(SwigClassMesh.klass, "getSkeleton", VALUEFUNC(_wrap_Mesh_getSkeleton), -1);
  rb_define_method(SwigClassMesh.klass, "getSkeletonName", VALUEFUNC(_wrap_Mesh_getSkeletonName), -1);
  rb_define_method(SwigClassMesh.klass, "_initAnimationState", VALUEFUNC(_wrap_Mesh__initAnimationState), -1);
  rb_define_method(SwigClassMesh.klass, "_refreshAnimationState", VALUEFUNC(_wrap_Mesh__refreshAnimationState), -1);
  rb_define_method(SwigClassMesh.klass, "addBoneAssignment", VALUEFUNC(_wrap_Mesh_addBoneAssignment), -1);
  rb_define_method(SwigClassMesh.klass, "clearBoneAssignments", VALUEFUNC(_wrap_Mesh_clearBoneAssignments), -1);
  rb_define_method(SwigClassMesh.klass, "_notifySkeleton", VALUEFUNC(_wrap_Mesh__notifySkeleton), -1);
  rb_define_method(SwigClassMesh.klass, "getBoneAssignmentIterator", VALUEFUNC(_wrap_Mesh_getBoneAssignmentIterator), -1);
  rb_define_method(SwigClassMesh.klass, "getBoneAssignments", VALUEFUNC(_wrap_Mesh_getBoneAssignments), -1);
  rb_define_method(SwigClassMesh.klass, "getNumLodLevels", VALUEFUNC(_wrap_Mesh_getNumLodLevels), -1);
  rb_define_method(SwigClassMesh.klass, "getLodLevel", VALUEFUNC(_wrap_Mesh_getLodLevel), -1);
  rb_define_method(SwigClassMesh.klass, "createManualLodLevel", VALUEFUNC(_wrap_Mesh_createManualLodLevel), -1);
  rb_define_method(SwigClassMesh.klass, "updateManualLodLevel", VALUEFUNC(_wrap_Mesh_updateManualLodLevel), -1);
  rb_define_method(SwigClassMesh.klass, "getLodIndex", VALUEFUNC(_wrap_Mesh_getLodIndex), -1);
  rb_define_method(SwigClassMesh.klass, "isLodManual", VALUEFUNC(_wrap_Mesh_isLodManual), -1);
  rb_define_method(SwigClassMesh.klass, "_setLodInfo", VALUEFUNC(_wrap_Mesh__setLodInfo), -1);
  rb_define_method(SwigClassMesh.klass, "_setLodUsage", VALUEFUNC(_wrap_Mesh__setLodUsage), -1);
  rb_define_method(SwigClassMesh.klass, "_setSubMeshLodFaceList", VALUEFUNC(_wrap_Mesh__setSubMeshLodFaceList), -1);
  rb_define_method(SwigClassMesh.klass, "removeLodLevels", VALUEFUNC(_wrap_Mesh_removeLodLevels), -1);
  rb_define_method(SwigClassMesh.klass, "setVertexBufferPolicy", VALUEFUNC(_wrap_Mesh_setVertexBufferPolicy), -1);
  rb_define_method(SwigClassMesh.klass, "setIndexBufferPolicy", VALUEFUNC(_wrap_Mesh_setIndexBufferPolicy), -1);
  rb_define_method(SwigClassMesh.klass, "getVertexBufferUsage", VALUEFUNC(_wrap_Mesh_getVertexBufferUsage), -1);
  rb_define_method(SwigClassMesh.klass, "getIndexBufferUsage", VALUEFUNC(_wrap_Mesh_getIndexBufferUsage), -1);
  rb_define_method(SwigClassMesh.klass, "isVertexBufferShadowed", VALUEFUNC(_wrap_Mesh_isVertexBufferShadowed), -1);
  rb_define_method(SwigClassMesh.klass, "isIndexBufferShadowed", VALUEFUNC(_wrap_Mesh_isIndexBufferShadowed), -1);
  rb_define_method(SwigClassMesh.klass, "_rationaliseBoneAssignments", VALUEFUNC(_wrap_Mesh__rationaliseBoneAssignments), -1);
  rb_define_method(SwigClassMesh.klass, "_compileBoneAssignments", VALUEFUNC(_wrap_Mesh__compileBoneAssignments), -1);
  rb_define_method(SwigClassMesh.klass, "_updateCompiledBoneAssignments", VALUEFUNC(_wrap_Mesh__updateCompiledBoneAssignments), -1);
  rb_define_method(SwigClassMesh.klass, "buildTangentVectors", VALUEFUNC(_wrap_Mesh_buildTangentVectors), -1);
  rb_define_method(SwigClassMesh.klass, "suggestTangentVectorBuildParams", VALUEFUNC(_wrap_Mesh_suggestTangentVectorBuildParams), -1);
  rb_define_method(SwigClassMesh.klass, "buildEdgeList", VALUEFUNC(_wrap_Mesh_buildEdgeList), -1);
  rb_define_method(SwigClassMesh.klass, "freeEdgeList", VALUEFUNC(_wrap_Mesh_freeEdgeList), -1);
  rb_define_method(SwigClassMesh.klass, "prepareForShadowVolume", VALUEFUNC(_wrap_Mesh_prepareForShadowVolume), -1);
  rb_define_method(SwigClassMesh.klass, "getEdgeList", VALUEFUNC(_wrap_Mesh_getEdgeList), -1);
  rb_define_method(SwigClassMesh.klass, "isPreparedForShadowVolumes", VALUEFUNC(_wrap_Mesh_isPreparedForShadowVolumes), -1);
  rb_define_method(SwigClassMesh.klass, "isEdgeListBuilt", VALUEFUNC(_wrap_Mesh_isEdgeListBuilt), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "prepareMatricesForVertexBlend", VALUEFUNC(_wrap_Mesh_prepareMatricesForVertexBlend), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "softwareVertexBlend", VALUEFUNC(_wrap_Mesh_softwareVertexBlend), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "softwareVertexMorph", VALUEFUNC(_wrap_Mesh_softwareVertexMorph), -1);
  rb_define_singleton_method(SwigClassMesh.klass, "softwareVertexPoseBlend", VALUEFUNC(_wrap_Mesh_softwareVertexPoseBlend), -1);
  rb_define_method(SwigClassMesh.klass, "getSubMeshNameMap", VALUEFUNC(_wrap_Mesh_getSubMeshNameMap), -1);
  rb_define_method(SwigClassMesh.klass, "setAutoBuildEdgeLists", VALUEFUNC(_wrap_Mesh_setAutoBuildEdgeLists), -1);
  rb_define_method(SwigClassMesh.klass, "getAutoBuildEdgeLists", VALUEFUNC(_wrap_Mesh_getAutoBuildEdgeLists), -1);
  rb_define_method(SwigClassMesh.klass, "getSharedVertexDataAnimationType", VALUEFUNC(_wrap_Mesh_getSharedVertexDataAnimationType), -1);
  rb_define_method(SwigClassMesh.klass, "getSharedVertexDataAnimationIncludesNormals", VALUEFUNC(_wrap_Mesh_getSharedVertexDataAnimationIncludesNormals), -1);
  rb_define_method(SwigClassMesh.klass, "createAnimation", VALUEFUNC(_wrap_Mesh_createAnimation), -1);
  rb_define_method(SwigClassMesh.klass, "_getAnimationImpl", VALUEFUNC(_wrap_Mesh__getAnimationImpl), -1);
  rb_define_method(SwigClassMesh.klass, "hasAnimation", VALUEFUNC(_wrap_Mesh_hasAnimation), -1);
  rb_define_method(SwigClassMesh.klass, "removeAnimation", VALUEFUNC(_wrap_Mesh_removeAnimation), -1);
  rb_define_method(SwigClassMesh.klass, "getNumAnimations", VALUEFUNC(_wrap_Mesh_getNumAnimations), -1);
  rb_define_method(SwigClassMesh.klass, "getAnimation", VALUEFUNC(_wrap_Mesh_getAnimation), -1);
  rb_define_method(SwigClassMesh.klass, "removeAllAnimations", VALUEFUNC(_wrap_Mesh_removeAllAnimations), -1);
  rb_define_method(SwigClassMesh.klass, "getVertexDataByTrackHandle", VALUEFUNC(_wrap_Mesh_getVertexDataByTrackHandle), -1);
  rb_define_method(SwigClassMesh.klass, "updateMaterialForAllSubMeshes", VALUEFUNC(_wrap_Mesh_updateMaterialForAllSubMeshes), -1);
  rb_define_method(SwigClassMesh.klass, "_determineAnimationTypes", VALUEFUNC(_wrap_Mesh__determineAnimationTypes), -1);
  rb_define_method(SwigClassMesh.klass, "_getAnimationTypesDirty", VALUEFUNC(_wrap_Mesh__getAnimationTypesDirty), -1);
  rb_define_method(SwigClassMesh.klass, "createPose", VALUEFUNC(_wrap_Mesh_createPose), -1);
  rb_define_method(SwigClassMesh.klass, "getPoseCount", VALUEFUNC(_wrap_Mesh_getPoseCount), -1);
  rb_define_method(SwigClassMesh.klass, "getPose", VALUEFUNC(_wrap_Mesh_getPose), -1);
  rb_define_method(SwigClassMesh.klass, "removePose", VALUEFUNC(_wrap_Mesh_removePose), -1);
  rb_define_method(SwigClassMesh.klass, "removeAllPoses", VALUEFUNC(_wrap_Mesh_removeAllPoses), -1);
  rb_define_method(SwigClassMesh.klass, "getPoseList", VALUEFUNC(_wrap_Mesh_getPoseList), -1);
  rb_define_method(SwigClassMesh.klass, "getLodStrategy", VALUEFUNC(_wrap_Mesh_getLodStrategy), -1);
  rb_define_method(SwigClassMesh.klass, "setLodStrategy", VALUEFUNC(_wrap_Mesh_setLodStrategy), -1);
  SwigClassMesh.mark = 0;
  SwigClassMesh.destroy = (void (*)(void *)) free_Ogre_Mesh;
  SwigClassMesh.trackObjects = 0;
  
  SwigClassMeshPtr.klass = rb_define_class_under(mOgre, "MeshPtr", ((swig_class *) SWIGTYPE_p_Ogre__SharedPtrT_Ogre__Mesh_t->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MeshPtr, (void *) &SwigClassMeshPtr);
  rb_define_alloc_func(SwigClassMeshPtr.klass, _wrap_MeshPtr_allocate);
  rb_define_method(SwigClassMeshPtr.klass, "initialize", VALUEFUNC(_wrap_new_MeshPtr), -1);
  SwigClassMeshPtr.mark = 0;
  SwigClassMeshPtr.destroy = (void (*)(void *)) free_Ogre_MeshPtr;
  SwigClassMeshPtr.trackObjects = 0;
  
  SwigClassMeshLodUsage.klass = rb_define_class_under(mOgre, "MeshLodUsage", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MeshLodUsage, (void *) &SwigClassMeshLodUsage);
  rb_define_alloc_func(SwigClassMeshLodUsage.klass, _wrap_MeshLodUsage_allocate);
  rb_define_method(SwigClassMeshLodUsage.klass, "initialize", VALUEFUNC(_wrap_new_MeshLodUsage), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "userValue=", VALUEFUNC(_wrap_MeshLodUsage_userValue_set), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "userValue", VALUEFUNC(_wrap_MeshLodUsage_userValue_get), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "value=", VALUEFUNC(_wrap_MeshLodUsage_value_set), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "value", VALUEFUNC(_wrap_MeshLodUsage_value_get), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "manualName=", VALUEFUNC(_wrap_MeshLodUsage_manualName_set), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "manualName", VALUEFUNC(_wrap_MeshLodUsage_manualName_get), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "manualGroup=", VALUEFUNC(_wrap_MeshLodUsage_manualGroup_set), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "manualGroup", VALUEFUNC(_wrap_MeshLodUsage_manualGroup_get), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "manualMesh=", VALUEFUNC(_wrap_MeshLodUsage_manualMesh_set), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "manualMesh", VALUEFUNC(_wrap_MeshLodUsage_manualMesh_get), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "edgeData=", VALUEFUNC(_wrap_MeshLodUsage_edgeData_set), -1);
  rb_define_method(SwigClassMeshLodUsage.klass, "edgeData", VALUEFUNC(_wrap_MeshLodUsage_edgeData_get), -1);
  SwigClassMeshLodUsage.mark = 0;
  SwigClassMeshLodUsage.destroy = (void (*)(void *)) free_Ogre_MeshLodUsage;
  SwigClassMeshLodUsage.trackObjects = 0;
  
  SwigClassNode.klass = rb_define_class_under(mOgre, "Node", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Node, (void *) &SwigClassNode);
  rb_undef_alloc_func(SwigClassNode.klass);
  rb_define_const(SwigClassNode.klass, "TS_LOCAL", SWIG_From_int(static_cast< int >(Ogre::Node::TS_LOCAL)));
  rb_define_const(SwigClassNode.klass, "TS_PARENT", SWIG_From_int(static_cast< int >(Ogre::Node::TS_PARENT)));
  rb_define_const(SwigClassNode.klass, "TS_WORLD", SWIG_From_int(static_cast< int >(Ogre::Node::TS_WORLD)));
  rb_define_method(SwigClassNode.klass, "getName", VALUEFUNC(_wrap_Node_getName), -1);
  rb_define_method(SwigClassNode.klass, "getParent", VALUEFUNC(_wrap_Node_getParent), -1);
  rb_define_method(SwigClassNode.klass, "getOrientation", VALUEFUNC(_wrap_Node_getOrientation), -1);
  rb_define_method(SwigClassNode.klass, "setOrientation", VALUEFUNC(_wrap_Node_setOrientation), -1);
  rb_define_method(SwigClassNode.klass, "resetOrientation", VALUEFUNC(_wrap_Node_resetOrientation), -1);
  rb_define_method(SwigClassNode.klass, "setPosition", VALUEFUNC(_wrap_Node_setPosition), -1);
  rb_define_method(SwigClassNode.klass, "getPosition", VALUEFUNC(_wrap_Node_getPosition), -1);
  rb_define_method(SwigClassNode.klass, "setScale", VALUEFUNC(_wrap_Node_setScale), -1);
  rb_define_method(SwigClassNode.klass, "getScale", VALUEFUNC(_wrap_Node_getScale), -1);
  rb_define_method(SwigClassNode.klass, "setInheritOrientation", VALUEFUNC(_wrap_Node_setInheritOrientation), -1);
  rb_define_method(SwigClassNode.klass, "getInheritOrientation", VALUEFUNC(_wrap_Node_getInheritOrientation), -1);
  rb_define_method(SwigClassNode.klass, "setInheritScale", VALUEFUNC(_wrap_Node_setInheritScale), -1);
  rb_define_method(SwigClassNode.klass, "getInheritScale", VALUEFUNC(_wrap_Node_getInheritScale), -1);
  rb_define_method(SwigClassNode.klass, "scale", VALUEFUNC(_wrap_Node_scale), -1);
  rb_define_method(SwigClassNode.klass, "translate", VALUEFUNC(_wrap_Node_translate), -1);
  rb_define_method(SwigClassNode.klass, "roll", VALUEFUNC(_wrap_Node_roll), -1);
  rb_define_method(SwigClassNode.klass, "pitch", VALUEFUNC(_wrap_Node_pitch), -1);
  rb_define_method(SwigClassNode.klass, "yaw", VALUEFUNC(_wrap_Node_yaw), -1);
  rb_define_method(SwigClassNode.klass, "rotate", VALUEFUNC(_wrap_Node_rotate), -1);
  rb_define_method(SwigClassNode.klass, "getLocalAxes", VALUEFUNC(_wrap_Node_getLocalAxes), -1);
  rb_define_method(SwigClassNode.klass, "createChild", VALUEFUNC(_wrap_Node_createChild), -1);
  rb_define_method(SwigClassNode.klass, "addChild", VALUEFUNC(_wrap_Node_addChild), -1);
  rb_define_method(SwigClassNode.klass, "numChildren", VALUEFUNC(_wrap_Node_numChildren), -1);
  rb_define_method(SwigClassNode.klass, "getChild", VALUEFUNC(_wrap_Node_getChild), -1);
  rb_define_method(SwigClassNode.klass, "removeChild", VALUEFUNC(_wrap_Node_removeChild), -1);
  rb_define_method(SwigClassNode.klass, "removeAllChildren", VALUEFUNC(_wrap_Node_removeAllChildren), -1);
  rb_define_method(SwigClassNode.klass, "_setDerivedPosition", VALUEFUNC(_wrap_Node__setDerivedPosition), -1);
  rb_define_method(SwigClassNode.klass, "_setDerivedOrientation", VALUEFUNC(_wrap_Node__setDerivedOrientation), -1);
  rb_define_method(SwigClassNode.klass, "_getDerivedOrientation", VALUEFUNC(_wrap_Node__getDerivedOrientation), -1);
  rb_define_method(SwigClassNode.klass, "_getDerivedPosition", VALUEFUNC(_wrap_Node__getDerivedPosition), -1);
  rb_define_method(SwigClassNode.klass, "_getDerivedScale", VALUEFUNC(_wrap_Node__getDerivedScale), -1);
  rb_define_method(SwigClassNode.klass, "_getFullTransform", VALUEFUNC(_wrap_Node__getFullTransform), -1);
  rb_define_method(SwigClassNode.klass, "_update", VALUEFUNC(_wrap_Node__update), -1);
  rb_define_method(SwigClassNode.klass, "setListener", VALUEFUNC(_wrap_Node_setListener), -1);
  rb_define_method(SwigClassNode.klass, "getListener", VALUEFUNC(_wrap_Node_getListener), -1);
  rb_define_method(SwigClassNode.klass, "setInitialState", VALUEFUNC(_wrap_Node_setInitialState), -1);
  rb_define_method(SwigClassNode.klass, "resetToInitialState", VALUEFUNC(_wrap_Node_resetToInitialState), -1);
  rb_define_method(SwigClassNode.klass, "getInitialPosition", VALUEFUNC(_wrap_Node_getInitialPosition), -1);
  rb_define_method(SwigClassNode.klass, "convertWorldToLocalPosition", VALUEFUNC(_wrap_Node_convertWorldToLocalPosition), -1);
  rb_define_method(SwigClassNode.klass, "convertLocalToWorldPosition", VALUEFUNC(_wrap_Node_convertLocalToWorldPosition), -1);
  rb_define_method(SwigClassNode.klass, "convertWorldToLocalOrientation", VALUEFUNC(_wrap_Node_convertWorldToLocalOrientation), -1);
  rb_define_method(SwigClassNode.klass, "convertLocalToWorldOrientation", VALUEFUNC(_wrap_Node_convertLocalToWorldOrientation), -1);
  rb_define_method(SwigClassNode.klass, "getInitialOrientation", VALUEFUNC(_wrap_Node_getInitialOrientation), -1);
  rb_define_method(SwigClassNode.klass, "getInitialScale", VALUEFUNC(_wrap_Node_getInitialScale), -1);
  rb_define_method(SwigClassNode.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_Node_getSquaredViewDepth), -1);
  rb_define_method(SwigClassNode.klass, "needUpdate", VALUEFUNC(_wrap_Node_needUpdate), -1);
  rb_define_method(SwigClassNode.klass, "requestUpdate", VALUEFUNC(_wrap_Node_requestUpdate), -1);
  rb_define_method(SwigClassNode.klass, "cancelUpdate", VALUEFUNC(_wrap_Node_cancelUpdate), -1);
  rb_define_method(SwigClassNode.klass, "getDebugRenderable", VALUEFUNC(_wrap_Node_getDebugRenderable), -1);
  rb_define_singleton_method(SwigClassNode.klass, "queueNeedUpdate", VALUEFUNC(_wrap_Node_queueNeedUpdate), -1);
  rb_define_singleton_method(SwigClassNode.klass, "processQueuedUpdates", VALUEFUNC(_wrap_Node_processQueuedUpdates), -1);
  rb_define_method(SwigClassNode.klass, "setUserAny", VALUEFUNC(_wrap_Node_setUserAny), -1);
  rb_define_method(SwigClassNode.klass, "getUserAny", VALUEFUNC(_wrap_Node_getUserAny), -1);
  rb_define_method(SwigClassNode.klass, "getUserObjectBindings", VALUEFUNC(_wrap_Node_getUserObjectBindings), -1);
  SwigClassNode.mark = 0;
  SwigClassNode.destroy = (void (*)(void *)) free_Ogre_Node;
  SwigClassNode.trackObjects = 0;
  
  SwigClassBone.klass = rb_define_class_under(mOgre, "Bone", ((swig_class *) SWIGTYPE_p_Ogre__Node->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Bone, (void *) &SwigClassBone);
  rb_define_alloc_func(SwigClassBone.klass, _wrap_Bone_allocate);
  rb_define_method(SwigClassBone.klass, "initialize", VALUEFUNC(_wrap_new_Bone), -1);
  rb_define_method(SwigClassBone.klass, "createChild", VALUEFUNC(_wrap_Bone_createChild), -1);
  rb_define_method(SwigClassBone.klass, "getHandle", VALUEFUNC(_wrap_Bone_getHandle), -1);
  rb_define_method(SwigClassBone.klass, "setBindingPose", VALUEFUNC(_wrap_Bone_setBindingPose), -1);
  rb_define_method(SwigClassBone.klass, "reset", VALUEFUNC(_wrap_Bone_reset), -1);
  rb_define_method(SwigClassBone.klass, "setManuallyControlled", VALUEFUNC(_wrap_Bone_setManuallyControlled), -1);
  rb_define_method(SwigClassBone.klass, "isManuallyControlled", VALUEFUNC(_wrap_Bone_isManuallyControlled), -1);
  rb_define_method(SwigClassBone.klass, "_getOffsetTransform", VALUEFUNC(_wrap_Bone__getOffsetTransform), -1);
  rb_define_method(SwigClassBone.klass, "_getBindingPoseInverseScale", VALUEFUNC(_wrap_Bone__getBindingPoseInverseScale), -1);
  rb_define_method(SwigClassBone.klass, "_getBindingPoseInversePosition", VALUEFUNC(_wrap_Bone__getBindingPoseInversePosition), -1);
  rb_define_method(SwigClassBone.klass, "_getBindingPoseInverseOrientation", VALUEFUNC(_wrap_Bone__getBindingPoseInverseOrientation), -1);
  rb_define_method(SwigClassBone.klass, "needUpdate", VALUEFUNC(_wrap_Bone_needUpdate), -1);
  SwigClassBone.mark = 0;
  SwigClassBone.destroy = (void (*)(void *)) free_Ogre_Bone;
  SwigClassBone.trackObjects = 0;
  rb_define_const(mOgre, "OGRE_COMPILER", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_IS_NATIVE_WCHAR_T", SWIG_From_int(static_cast< int >(0)));
  
  SwigClassUTFString.klass = rb_define_class_under(mOgre, "UTFString", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__UTFString, (void *) &SwigClassUTFString);
  rb_define_alloc_func(SwigClassUTFString.klass, _wrap_UTFString_allocate);
  rb_define_method(SwigClassUTFString.klass, "initialize", VALUEFUNC(_wrap_new_UTFString), -1);
  rb_define_const(SwigClassUTFString.klass, "Npos", SWIG_From_size_t(static_cast< size_t >(Ogre::UTFString::npos)));
  rb_define_method(SwigClassUTFString.klass, "size", VALUEFUNC(_wrap_UTFString_size), -1);
  rb_define_method(SwigClassUTFString.klass, "length", VALUEFUNC(_wrap_UTFString_length), -1);
  rb_define_method(SwigClassUTFString.klass, "length_Characters", VALUEFUNC(_wrap_UTFString_length_Characters), -1);
  rb_define_method(SwigClassUTFString.klass, "max_size", VALUEFUNC(_wrap_UTFString_max_size), -1);
  rb_define_method(SwigClassUTFString.klass, "reserve", VALUEFUNC(_wrap_UTFString_reserve), -1);
  rb_define_method(SwigClassUTFString.klass, "resize", VALUEFUNC(_wrap_UTFString_resize), -1);
  rb_define_method(SwigClassUTFString.klass, "swap", VALUEFUNC(_wrap_UTFString_swap), -1);
  rb_define_method(SwigClassUTFString.klass, "empty", VALUEFUNC(_wrap_UTFString_empty), -1);
  rb_define_method(SwigClassUTFString.klass, "c_str", VALUEFUNC(_wrap_UTFString_c_str), -1);
  rb_define_method(SwigClassUTFString.klass, "data", VALUEFUNC(_wrap_UTFString_data), -1);
  rb_define_method(SwigClassUTFString.klass, "capacity", VALUEFUNC(_wrap_UTFString_capacity), -1);
  rb_define_method(SwigClassUTFString.klass, "clear", VALUEFUNC(_wrap_UTFString_clear), -1);
  rb_define_method(SwigClassUTFString.klass, "substr", VALUEFUNC(_wrap_UTFString_substr), -1);
  rb_define_method(SwigClassUTFString.klass, "push_back", VALUEFUNC(_wrap_UTFString_push_back), -1);
  rb_define_method(SwigClassUTFString.klass, "inString", VALUEFUNC(_wrap_UTFString_inString), -1);
  rb_define_method(SwigClassUTFString.klass, "asUTF8", VALUEFUNC(_wrap_UTFString_asUTF8), -1);
  rb_define_method(SwigClassUTFString.klass, "asUTF8_c_str", VALUEFUNC(_wrap_UTFString_asUTF8_c_str), -1);
  rb_define_method(SwigClassUTFString.klass, "asUTF32", VALUEFUNC(_wrap_UTFString_asUTF32), -1);
  rb_define_method(SwigClassUTFString.klass, "asUTF32_c_str", VALUEFUNC(_wrap_UTFString_asUTF32_c_str), -1);
  rb_define_method(SwigClassUTFString.klass, "asWStr", VALUEFUNC(_wrap_UTFString_asWStr), -1);
  rb_define_method(SwigClassUTFString.klass, "asWStr_c_str", VALUEFUNC(_wrap_UTFString_asWStr_c_str), -1);
  rb_define_method(SwigClassUTFString.klass, "at", VALUEFUNC(_wrap_UTFString_at), -1);
  rb_define_method(SwigClassUTFString.klass, "getChar", VALUEFUNC(_wrap_UTFString_getChar), -1);
  rb_define_method(SwigClassUTFString.klass, "setChar", VALUEFUNC(_wrap_UTFString_setChar), -1);
  rb_define_method(SwigClassUTFString.klass, "begin", VALUEFUNC(_wrap_UTFString_begin), -1);
  rb_define_method(SwigClassUTFString.klass, "end", VALUEFUNC(_wrap_UTFString_end), -1);
  rb_define_method(SwigClassUTFString.klass, "rbegin", VALUEFUNC(_wrap_UTFString_rbegin), -1);
  rb_define_method(SwigClassUTFString.klass, "rend", VALUEFUNC(_wrap_UTFString_rend), -1);
  rb_define_method(SwigClassUTFString.klass, "assign", VALUEFUNC(_wrap_UTFString_assign), -1);
  rb_define_method(SwigClassUTFString.klass, "append", VALUEFUNC(_wrap_UTFString_append), -1);
  rb_define_method(SwigClassUTFString.klass, "insert", VALUEFUNC(_wrap_UTFString_insert), -1);
  rb_define_method(SwigClassUTFString.klass, "erase", VALUEFUNC(_wrap_UTFString_erase), -1);
  rb_define_method(SwigClassUTFString.klass, "replace", VALUEFUNC(_wrap_UTFString_replace), -1);
  rb_define_method(SwigClassUTFString.klass, "compare", VALUEFUNC(_wrap_UTFString_compare), -1);
  rb_define_method(SwigClassUTFString.klass, "find", VALUEFUNC(_wrap_UTFString_find), -1);
  rb_define_method(SwigClassUTFString.klass, "rfind", VALUEFUNC(_wrap_UTFString_rfind), -1);
  rb_define_method(SwigClassUTFString.klass, "find_first_of", VALUEFUNC(_wrap_UTFString_find_first_of), -1);
  rb_define_method(SwigClassUTFString.klass, "find_first_not_of", VALUEFUNC(_wrap_UTFString_find_first_not_of), -1);
  rb_define_method(SwigClassUTFString.klass, "find_last_of", VALUEFUNC(_wrap_UTFString_find_last_of), -1);
  rb_define_method(SwigClassUTFString.klass, "find_last_not_of", VALUEFUNC(_wrap_UTFString_find_last_not_of), -1);
  rb_define_method(SwigClassUTFString.klass, "<", VALUEFUNC(_wrap_UTFString___lt__), -1);
  rb_define_method(SwigClassUTFString.klass, "<=", VALUEFUNC(_wrap_UTFString___le__), -1);
  rb_define_method(SwigClassUTFString.klass, ">", VALUEFUNC(_wrap_UTFString___gt__), -1);
  rb_define_method(SwigClassUTFString.klass, ">=", VALUEFUNC(_wrap_UTFString___ge__), -1);
  rb_define_method(SwigClassUTFString.klass, "==", VALUEFUNC(_wrap_UTFString___eq__), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf16_independent_char", VALUEFUNC(_wrap_UTFString__utf16_independent_char), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf16_surrogate_lead", VALUEFUNC(_wrap_UTFString__utf16_surrogate_lead), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf16_surrogate_follow", VALUEFUNC(_wrap_UTFString__utf16_surrogate_follow), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf16_char_length", VALUEFUNC(_wrap_UTFString__utf16_char_length), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf16_to_utf32", VALUEFUNC(_wrap_UTFString__utf16_to_utf32), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf32_to_utf16", VALUEFUNC(_wrap_UTFString__utf32_to_utf16), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf8_start_char", VALUEFUNC(_wrap_UTFString__utf8_start_char), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf8_char_length", VALUEFUNC(_wrap_UTFString__utf8_char_length), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf8_to_utf32", VALUEFUNC(_wrap_UTFString__utf8_to_utf32), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_utf32_to_utf8", VALUEFUNC(_wrap_UTFString__utf32_to_utf8), -1);
  rb_define_singleton_method(SwigClassUTFString.klass, "_verifyUTF8", VALUEFUNC(_wrap_UTFString__verifyUTF8), -1);
  SwigClassUTFString.mark = 0;
  SwigClassUTFString.destroy = (void (*)(void *)) free_Ogre_UTFString;
  SwigClassUTFString.trackObjects = 0;
  rb_define_module_function(mOgre, "+", VALUEFUNC(_wrap___add__), -1);
  rb_define_module_function(mOgre, "-", VALUEFUNC(_wrap___sub__), -1);
  rb_define_module_function(mOgre, "<", VALUEFUNC(_wrap___lt__), -1);
  rb_define_module_function(mOgre, "<=", VALUEFUNC(_wrap___le__), -1);
  rb_define_module_function(mOgre, ">", VALUEFUNC(_wrap___gt__), -1);
  rb_define_module_function(mOgre, ">=", VALUEFUNC(_wrap___ge__), -1);
  rb_define_module_function(mOgre, "<<", VALUEFUNC(_wrap___lshift__), -1);
  
  SwigClassCmdLeft.klass = rb_define_class_under(mOgre, "CmdLeft", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdLeft, (void *) &SwigClassCmdLeft);
  rb_define_alloc_func(SwigClassCmdLeft.klass, _wrap_CmdLeft_allocate);
  rb_define_method(SwigClassCmdLeft.klass, "initialize", VALUEFUNC(_wrap_new_CmdLeft), -1);
  rb_define_method(SwigClassCmdLeft.klass, "doGet", VALUEFUNC(_wrap_CmdLeft_doGet), -1);
  rb_define_method(SwigClassCmdLeft.klass, "doSet", VALUEFUNC(_wrap_CmdLeft_doSet), -1);
  SwigClassCmdLeft.mark = 0;
  SwigClassCmdLeft.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdLeft;
  SwigClassCmdLeft.trackObjects = 0;
  
  SwigClassCmdTop.klass = rb_define_class_under(mOgre, "CmdTop", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdTop, (void *) &SwigClassCmdTop);
  rb_define_alloc_func(SwigClassCmdTop.klass, _wrap_CmdTop_allocate);
  rb_define_method(SwigClassCmdTop.klass, "initialize", VALUEFUNC(_wrap_new_CmdTop), -1);
  rb_define_method(SwigClassCmdTop.klass, "doGet", VALUEFUNC(_wrap_CmdTop_doGet), -1);
  rb_define_method(SwigClassCmdTop.klass, "doSet", VALUEFUNC(_wrap_CmdTop_doSet), -1);
  SwigClassCmdTop.mark = 0;
  SwigClassCmdTop.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdTop;
  SwigClassCmdTop.trackObjects = 0;
  
  SwigClassCmdWidth.klass = rb_define_class_under(mOgre, "CmdWidth", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdWidth, (void *) &SwigClassCmdWidth);
  rb_define_alloc_func(SwigClassCmdWidth.klass, _wrap_CmdWidth_allocate);
  rb_define_method(SwigClassCmdWidth.klass, "initialize", VALUEFUNC(_wrap_new_CmdWidth), -1);
  rb_define_method(SwigClassCmdWidth.klass, "doGet", VALUEFUNC(_wrap_CmdWidth_doGet), -1);
  rb_define_method(SwigClassCmdWidth.klass, "doSet", VALUEFUNC(_wrap_CmdWidth_doSet), -1);
  SwigClassCmdWidth.mark = 0;
  SwigClassCmdWidth.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdWidth;
  SwigClassCmdWidth.trackObjects = 0;
  
  SwigClassCmdHeight.klass = rb_define_class_under(mOgre, "CmdHeight", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdHeight, (void *) &SwigClassCmdHeight);
  rb_define_alloc_func(SwigClassCmdHeight.klass, _wrap_CmdHeight_allocate);
  rb_define_method(SwigClassCmdHeight.klass, "initialize", VALUEFUNC(_wrap_new_CmdHeight), -1);
  rb_define_method(SwigClassCmdHeight.klass, "doGet", VALUEFUNC(_wrap_CmdHeight_doGet), -1);
  rb_define_method(SwigClassCmdHeight.klass, "doSet", VALUEFUNC(_wrap_CmdHeight_doSet), -1);
  SwigClassCmdHeight.mark = 0;
  SwigClassCmdHeight.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdHeight;
  SwigClassCmdHeight.trackObjects = 0;
  
  SwigClassCmdMaterial.klass = rb_define_class_under(mOgre, "CmdMaterial", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdMaterial, (void *) &SwigClassCmdMaterial);
  rb_define_alloc_func(SwigClassCmdMaterial.klass, _wrap_CmdMaterial_allocate);
  rb_define_method(SwigClassCmdMaterial.klass, "initialize", VALUEFUNC(_wrap_new_CmdMaterial), -1);
  rb_define_method(SwigClassCmdMaterial.klass, "doGet", VALUEFUNC(_wrap_CmdMaterial_doGet), -1);
  rb_define_method(SwigClassCmdMaterial.klass, "doSet", VALUEFUNC(_wrap_CmdMaterial_doSet), -1);
  SwigClassCmdMaterial.mark = 0;
  SwigClassCmdMaterial.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdMaterial;
  SwigClassCmdMaterial.trackObjects = 0;
  
  SwigClassCmdCaption.klass = rb_define_class_under(mOgre, "CmdCaption", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdCaption, (void *) &SwigClassCmdCaption);
  rb_define_alloc_func(SwigClassCmdCaption.klass, _wrap_CmdCaption_allocate);
  rb_define_method(SwigClassCmdCaption.klass, "initialize", VALUEFUNC(_wrap_new_CmdCaption), -1);
  rb_define_method(SwigClassCmdCaption.klass, "doGet", VALUEFUNC(_wrap_CmdCaption_doGet), -1);
  rb_define_method(SwigClassCmdCaption.klass, "doSet", VALUEFUNC(_wrap_CmdCaption_doSet), -1);
  SwigClassCmdCaption.mark = 0;
  SwigClassCmdCaption.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdCaption;
  SwigClassCmdCaption.trackObjects = 0;
  
  SwigClassCmdMetricsMode.klass = rb_define_class_under(mOgre, "CmdMetricsMode", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdMetricsMode, (void *) &SwigClassCmdMetricsMode);
  rb_define_alloc_func(SwigClassCmdMetricsMode.klass, _wrap_CmdMetricsMode_allocate);
  rb_define_method(SwigClassCmdMetricsMode.klass, "initialize", VALUEFUNC(_wrap_new_CmdMetricsMode), -1);
  rb_define_method(SwigClassCmdMetricsMode.klass, "doGet", VALUEFUNC(_wrap_CmdMetricsMode_doGet), -1);
  rb_define_method(SwigClassCmdMetricsMode.klass, "doSet", VALUEFUNC(_wrap_CmdMetricsMode_doSet), -1);
  SwigClassCmdMetricsMode.mark = 0;
  SwigClassCmdMetricsMode.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdMetricsMode;
  SwigClassCmdMetricsMode.trackObjects = 0;
  
  SwigClassCmdHorizontalAlign.klass = rb_define_class_under(mOgre, "CmdHorizontalAlign", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdHorizontalAlign, (void *) &SwigClassCmdHorizontalAlign);
  rb_define_alloc_func(SwigClassCmdHorizontalAlign.klass, _wrap_CmdHorizontalAlign_allocate);
  rb_define_method(SwigClassCmdHorizontalAlign.klass, "initialize", VALUEFUNC(_wrap_new_CmdHorizontalAlign), -1);
  rb_define_method(SwigClassCmdHorizontalAlign.klass, "doGet", VALUEFUNC(_wrap_CmdHorizontalAlign_doGet), -1);
  rb_define_method(SwigClassCmdHorizontalAlign.klass, "doSet", VALUEFUNC(_wrap_CmdHorizontalAlign_doSet), -1);
  SwigClassCmdHorizontalAlign.mark = 0;
  SwigClassCmdHorizontalAlign.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdHorizontalAlign;
  SwigClassCmdHorizontalAlign.trackObjects = 0;
  
  SwigClassCmdVerticalAlign.klass = rb_define_class_under(mOgre, "CmdVerticalAlign", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdVerticalAlign, (void *) &SwigClassCmdVerticalAlign);
  rb_define_alloc_func(SwigClassCmdVerticalAlign.klass, _wrap_CmdVerticalAlign_allocate);
  rb_define_method(SwigClassCmdVerticalAlign.klass, "initialize", VALUEFUNC(_wrap_new_CmdVerticalAlign), -1);
  rb_define_method(SwigClassCmdVerticalAlign.klass, "doGet", VALUEFUNC(_wrap_CmdVerticalAlign_doGet), -1);
  rb_define_method(SwigClassCmdVerticalAlign.klass, "doSet", VALUEFUNC(_wrap_CmdVerticalAlign_doSet), -1);
  SwigClassCmdVerticalAlign.mark = 0;
  SwigClassCmdVerticalAlign.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdVerticalAlign;
  SwigClassCmdVerticalAlign.trackObjects = 0;
  
  SwigClassCmdVisible.klass = rb_define_class_under(mOgre, "CmdVisible", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementCommands__CmdVisible, (void *) &SwigClassCmdVisible);
  rb_define_alloc_func(SwigClassCmdVisible.klass, _wrap_CmdVisible_allocate);
  rb_define_method(SwigClassCmdVisible.klass, "initialize", VALUEFUNC(_wrap_new_CmdVisible), -1);
  rb_define_method(SwigClassCmdVisible.klass, "doGet", VALUEFUNC(_wrap_CmdVisible_doGet), -1);
  rb_define_method(SwigClassCmdVisible.klass, "doSet", VALUEFUNC(_wrap_CmdVisible_doSet), -1);
  SwigClassCmdVisible.mark = 0;
  SwigClassCmdVisible.destroy = (void (*)(void *)) free_Ogre_OverlayElementCommands_CmdVisible;
  SwigClassCmdVisible.trackObjects = 0;
  
  SwigClassRectangle.klass = rb_define_class_under(mOgre, "Rectangle", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Rectangle, (void *) &SwigClassRectangle);
  rb_define_alloc_func(SwigClassRectangle.klass, _wrap_Rectangle_allocate);
  rb_define_method(SwigClassRectangle.klass, "initialize", VALUEFUNC(_wrap_new_Rectangle), -1);
  rb_define_method(SwigClassRectangle.klass, "left=", VALUEFUNC(_wrap_Rectangle_left_set), -1);
  rb_define_method(SwigClassRectangle.klass, "left", VALUEFUNC(_wrap_Rectangle_left_get), -1);
  rb_define_method(SwigClassRectangle.klass, "top=", VALUEFUNC(_wrap_Rectangle_top_set), -1);
  rb_define_method(SwigClassRectangle.klass, "top", VALUEFUNC(_wrap_Rectangle_top_get), -1);
  rb_define_method(SwigClassRectangle.klass, "right=", VALUEFUNC(_wrap_Rectangle_right_set), -1);
  rb_define_method(SwigClassRectangle.klass, "right", VALUEFUNC(_wrap_Rectangle_right_get), -1);
  rb_define_method(SwigClassRectangle.klass, "bottom=", VALUEFUNC(_wrap_Rectangle_bottom_set), -1);
  rb_define_method(SwigClassRectangle.klass, "bottom", VALUEFUNC(_wrap_Rectangle_bottom_get), -1);
  rb_define_method(SwigClassRectangle.klass, "inside", VALUEFUNC(_wrap_Rectangle_inside), -1);
  SwigClassRectangle.mark = 0;
  SwigClassRectangle.destroy = (void (*)(void *)) free_Ogre_Rectangle;
  SwigClassRectangle.trackObjects = 0;
  rb_define_module_function(mOgre, "intersect", VALUEFUNC(_wrap_intersect), -1);
  rb_define_const(mOgre, "GMM_RELATIVE", SWIG_From_int(static_cast< int >(Ogre::GMM_RELATIVE)));
  rb_define_const(mOgre, "GMM_PIXELS", SWIG_From_int(static_cast< int >(Ogre::GMM_PIXELS)));
  rb_define_const(mOgre, "GMM_RELATIVE_ASPECT_ADJUSTED", SWIG_From_int(static_cast< int >(Ogre::GMM_RELATIVE_ASPECT_ADJUSTED)));
  rb_define_const(mOgre, "GHA_LEFT", SWIG_From_int(static_cast< int >(Ogre::GHA_LEFT)));
  rb_define_const(mOgre, "GHA_CENTER", SWIG_From_int(static_cast< int >(Ogre::GHA_CENTER)));
  rb_define_const(mOgre, "GHA_RIGHT", SWIG_From_int(static_cast< int >(Ogre::GHA_RIGHT)));
  rb_define_const(mOgre, "GVA_TOP", SWIG_From_int(static_cast< int >(Ogre::GVA_TOP)));
  rb_define_const(mOgre, "GVA_CENTER", SWIG_From_int(static_cast< int >(Ogre::GVA_CENTER)));
  rb_define_const(mOgre, "GVA_BOTTOM", SWIG_From_int(static_cast< int >(Ogre::GVA_BOTTOM)));
  
  SwigClassOverlayElement.klass = rb_define_class_under(mOgre, "OverlayElement", ((swig_class *) SWIGTYPE_p_Ogre__StringInterface->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElement, (void *) &SwigClassOverlayElement);
  rb_undef_alloc_func(SwigClassOverlayElement.klass);
  rb_define_method(SwigClassOverlayElement.klass, "initialise", VALUEFUNC(_wrap_OverlayElement_initialise), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getName", VALUEFUNC(_wrap_OverlayElement_getName), -1);
  rb_define_method(SwigClassOverlayElement.klass, "show", VALUEFUNC(_wrap_OverlayElement_show), -1);
  rb_define_method(SwigClassOverlayElement.klass, "hide", VALUEFUNC(_wrap_OverlayElement_hide), -1);
  rb_define_method(SwigClassOverlayElement.klass, "isVisible", VALUEFUNC(_wrap_OverlayElement_isVisible), -1);
  rb_define_method(SwigClassOverlayElement.klass, "isEnabled", VALUEFUNC(_wrap_OverlayElement_isEnabled), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setEnabled", VALUEFUNC(_wrap_OverlayElement_setEnabled), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setDimensions", VALUEFUNC(_wrap_OverlayElement_setDimensions), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setPosition", VALUEFUNC(_wrap_OverlayElement_setPosition), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setWidth", VALUEFUNC(_wrap_OverlayElement_setWidth), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getWidth", VALUEFUNC(_wrap_OverlayElement_getWidth), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setHeight", VALUEFUNC(_wrap_OverlayElement_setHeight), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getHeight", VALUEFUNC(_wrap_OverlayElement_getHeight), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setLeft", VALUEFUNC(_wrap_OverlayElement_setLeft), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getLeft", VALUEFUNC(_wrap_OverlayElement_getLeft), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setTop", VALUEFUNC(_wrap_OverlayElement_setTop), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getTop", VALUEFUNC(_wrap_OverlayElement_getTop), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getLeft", VALUEFUNC(_wrap_OverlayElement__getLeft), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getTop", VALUEFUNC(_wrap_OverlayElement__getTop), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getWidth", VALUEFUNC(_wrap_OverlayElement__getWidth), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getHeight", VALUEFUNC(_wrap_OverlayElement__getHeight), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_setLeft", VALUEFUNC(_wrap_OverlayElement__setLeft), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_setTop", VALUEFUNC(_wrap_OverlayElement__setTop), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_setWidth", VALUEFUNC(_wrap_OverlayElement__setWidth), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_setHeight", VALUEFUNC(_wrap_OverlayElement__setHeight), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_setPosition", VALUEFUNC(_wrap_OverlayElement__setPosition), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_setDimensions", VALUEFUNC(_wrap_OverlayElement__setDimensions), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getMaterialName", VALUEFUNC(_wrap_OverlayElement_getMaterialName), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setMaterialName", VALUEFUNC(_wrap_OverlayElement_setMaterialName), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getMaterial", VALUEFUNC(_wrap_OverlayElement_getMaterial), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getWorldTransforms", VALUEFUNC(_wrap_OverlayElement_getWorldTransforms), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_positionsOutOfDate", VALUEFUNC(_wrap_OverlayElement__positionsOutOfDate), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_update", VALUEFUNC(_wrap_OverlayElement__update), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_updateFromParent", VALUEFUNC(_wrap_OverlayElement__updateFromParent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notifyParent", VALUEFUNC(_wrap_OverlayElement__notifyParent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getDerivedLeft", VALUEFUNC(_wrap_OverlayElement__getDerivedLeft), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getDerivedTop", VALUEFUNC(_wrap_OverlayElement__getDerivedTop), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getRelativeWidth", VALUEFUNC(_wrap_OverlayElement__getRelativeWidth), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getRelativeHeight", VALUEFUNC(_wrap_OverlayElement__getRelativeHeight), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_getClippingRegion", VALUEFUNC(_wrap_OverlayElement__getClippingRegion), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notifyZOrder", VALUEFUNC(_wrap_OverlayElement__notifyZOrder), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notifyWorldTransforms", VALUEFUNC(_wrap_OverlayElement__notifyWorldTransforms), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_notifyViewport", VALUEFUNC(_wrap_OverlayElement__notifyViewport), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_updateRenderQueue", VALUEFUNC(_wrap_OverlayElement__updateRenderQueue), -1);
  rb_define_method(SwigClassOverlayElement.klass, "visitRenderables", VALUEFUNC(_wrap_OverlayElement_visitRenderables), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getTypeName", VALUEFUNC(_wrap_OverlayElement_getTypeName), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setCaption", VALUEFUNC(_wrap_OverlayElement_setCaption), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getCaption", VALUEFUNC(_wrap_OverlayElement_getCaption), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setColour", VALUEFUNC(_wrap_OverlayElement_setColour), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getColour", VALUEFUNC(_wrap_OverlayElement_getColour), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setMetricsMode", VALUEFUNC(_wrap_OverlayElement_setMetricsMode), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getMetricsMode", VALUEFUNC(_wrap_OverlayElement_getMetricsMode), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setHorizontalAlignment", VALUEFUNC(_wrap_OverlayElement_setHorizontalAlignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getHorizontalAlignment", VALUEFUNC(_wrap_OverlayElement_getHorizontalAlignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setVerticalAlignment", VALUEFUNC(_wrap_OverlayElement_setVerticalAlignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getVerticalAlignment", VALUEFUNC(_wrap_OverlayElement_getVerticalAlignment), -1);
  rb_define_method(SwigClassOverlayElement.klass, "contains", VALUEFUNC(_wrap_OverlayElement_contains), -1);
  rb_define_method(SwigClassOverlayElement.klass, "findElementAt", VALUEFUNC(_wrap_OverlayElement_findElementAt), -1);
  rb_define_method(SwigClassOverlayElement.klass, "isContainer", VALUEFUNC(_wrap_OverlayElement_isContainer), -1);
  rb_define_method(SwigClassOverlayElement.klass, "isKeyEnabled", VALUEFUNC(_wrap_OverlayElement_isKeyEnabled), -1);
  rb_define_method(SwigClassOverlayElement.klass, "isCloneable", VALUEFUNC(_wrap_OverlayElement_isCloneable), -1);
  rb_define_method(SwigClassOverlayElement.klass, "setCloneable", VALUEFUNC(_wrap_OverlayElement_setCloneable), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getParent", VALUEFUNC(_wrap_OverlayElement_getParent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "_setParent", VALUEFUNC(_wrap_OverlayElement__setParent), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getZOrder", VALUEFUNC(_wrap_OverlayElement_getZOrder), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_OverlayElement_getSquaredViewDepth), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getLights", VALUEFUNC(_wrap_OverlayElement_getLights), -1);
  rb_define_method(SwigClassOverlayElement.klass, "copyFromTemplate", VALUEFUNC(_wrap_OverlayElement_copyFromTemplate), -1);
  rb_define_method(SwigClassOverlayElement.klass, "clone", VALUEFUNC(_wrap_OverlayElement_clone), -1);
  rb_define_method(SwigClassOverlayElement.klass, "getSourceTemplate", VALUEFUNC(_wrap_OverlayElement_getSourceTemplate), -1);
  SwigClassOverlayElement.mark = 0;
  SwigClassOverlayElement.destroy = (void (*)(void *)) free_Ogre_OverlayElement;
  SwigClassOverlayElement.trackObjects = 0;
  
  SwigClassOverlayContainer.klass = rb_define_class_under(mOgre, "OverlayContainer", ((swig_class *) SWIGTYPE_p_Ogre__OverlayElement->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayContainer, (void *) &SwigClassOverlayContainer);
  rb_undef_alloc_func(SwigClassOverlayContainer.klass);
  rb_define_method(SwigClassOverlayContainer.klass, "addChild", VALUEFUNC(_wrap_OverlayContainer_addChild), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "addChildImpl", VALUEFUNC(_wrap_OverlayContainer_addChildImpl), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "removeChild", VALUEFUNC(_wrap_OverlayContainer_removeChild), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "getChild", VALUEFUNC(_wrap_OverlayContainer_getChild), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "initialise", VALUEFUNC(_wrap_OverlayContainer_initialise), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_addChild", VALUEFUNC(_wrap_OverlayContainer__addChild), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_removeChild", VALUEFUNC(_wrap_OverlayContainer__removeChild), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "getChildIterator", VALUEFUNC(_wrap_OverlayContainer_getChildIterator), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "getChildContainerIterator", VALUEFUNC(_wrap_OverlayContainer_getChildContainerIterator), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_positionsOutOfDate", VALUEFUNC(_wrap_OverlayContainer__positionsOutOfDate), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_update", VALUEFUNC(_wrap_OverlayContainer__update), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notifyZOrder", VALUEFUNC(_wrap_OverlayContainer__notifyZOrder), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notifyViewport", VALUEFUNC(_wrap_OverlayContainer__notifyViewport), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notifyWorldTransforms", VALUEFUNC(_wrap_OverlayContainer__notifyWorldTransforms), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_notifyParent", VALUEFUNC(_wrap_OverlayContainer__notifyParent), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "_updateRenderQueue", VALUEFUNC(_wrap_OverlayContainer__updateRenderQueue), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "isContainer", VALUEFUNC(_wrap_OverlayContainer_isContainer), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "isChildrenProcessEvents", VALUEFUNC(_wrap_OverlayContainer_isChildrenProcessEvents), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "setChildrenProcessEvents", VALUEFUNC(_wrap_OverlayContainer_setChildrenProcessEvents), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "findElementAt", VALUEFUNC(_wrap_OverlayContainer_findElementAt), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "copyFromTemplate", VALUEFUNC(_wrap_OverlayContainer_copyFromTemplate), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "clone", VALUEFUNC(_wrap_OverlayContainer_clone), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "each_child", VALUEFUNC(_wrap_OverlayContainer_each_child), -1);
  rb_define_method(SwigClassOverlayContainer.klass, "each_child_container", VALUEFUNC(_wrap_OverlayContainer_each_child_container), -1);
  rb_define_singleton_method(SwigClassOverlayContainer.klass, "cast", VALUEFUNC(_wrap_OverlayContainer_cast), -1);
  SwigClassOverlayContainer.mark = 0;
  SwigClassOverlayContainer.destroy = (void (*)(void *)) free_Ogre_OverlayContainer;
  SwigClassOverlayContainer.trackObjects = 0;
  
  SwigClassPanelOverlayElement.klass = rb_define_class_under(mOgre, "PanelOverlayElement", ((swig_class *) SWIGTYPE_p_Ogre__OverlayContainer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PanelOverlayElement, (void *) &SwigClassPanelOverlayElement);
  rb_define_alloc_func(SwigClassPanelOverlayElement.klass, _wrap_PanelOverlayElement_allocate);
  rb_define_method(SwigClassPanelOverlayElement.klass, "initialize", VALUEFUNC(_wrap_new_PanelOverlayElement), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "initialise", VALUEFUNC(_wrap_PanelOverlayElement_initialise), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "setTiling", VALUEFUNC(_wrap_PanelOverlayElement_setTiling), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "getTileX", VALUEFUNC(_wrap_PanelOverlayElement_getTileX), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "getTileY", VALUEFUNC(_wrap_PanelOverlayElement_getTileY), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "setUV", VALUEFUNC(_wrap_PanelOverlayElement_setUV), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "getUV", VALUEFUNC(_wrap_PanelOverlayElement_getUV), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "setTransparent", VALUEFUNC(_wrap_PanelOverlayElement_setTransparent), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "isTransparent", VALUEFUNC(_wrap_PanelOverlayElement_isTransparent), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "getTypeName", VALUEFUNC(_wrap_PanelOverlayElement_getTypeName), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "getRenderOperation", VALUEFUNC(_wrap_PanelOverlayElement_getRenderOperation), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "setMaterialName", VALUEFUNC(_wrap_PanelOverlayElement_setMaterialName), -1);
  rb_define_method(SwigClassPanelOverlayElement.klass, "_updateRenderQueue", VALUEFUNC(_wrap_PanelOverlayElement__updateRenderQueue), -1);
  rb_define_singleton_method(SwigClassPanelOverlayElement.klass, "cast", VALUEFUNC(_wrap_PanelOverlayElement_cast), -1);
  SwigClassPanelOverlayElement.mark = 0;
  SwigClassPanelOverlayElement.destroy = (void (*)(void *)) free_Ogre_PanelOverlayElement;
  SwigClassPanelOverlayElement.trackObjects = 0;
  
  SwigClassBorderPanelOverlayElement.klass = rb_define_class_under(mOgre, "BorderPanelOverlayElement", ((swig_class *) SWIGTYPE_p_Ogre__PanelOverlayElement->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BorderPanelOverlayElement, (void *) &SwigClassBorderPanelOverlayElement);
  rb_define_alloc_func(SwigClassBorderPanelOverlayElement.klass, _wrap_BorderPanelOverlayElement_allocate);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "initialize", VALUEFUNC(_wrap_new_BorderPanelOverlayElement), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "initialise", VALUEFUNC(_wrap_BorderPanelOverlayElement_initialise), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getTypeName", VALUEFUNC(_wrap_BorderPanelOverlayElement_getTypeName), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setBorderSize", VALUEFUNC(_wrap_BorderPanelOverlayElement_setBorderSize), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getLeftBorderSize", VALUEFUNC(_wrap_BorderPanelOverlayElement_getLeftBorderSize), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getRightBorderSize", VALUEFUNC(_wrap_BorderPanelOverlayElement_getRightBorderSize), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getTopBorderSize", VALUEFUNC(_wrap_BorderPanelOverlayElement_getTopBorderSize), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getBottomBorderSize", VALUEFUNC(_wrap_BorderPanelOverlayElement_getBottomBorderSize), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setLeftBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setLeftBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setRightBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setRightBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setTopBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setTopBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setBottomBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setBottomBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setTopLeftBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setTopLeftBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setTopRightBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setTopRightBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setBottomLeftBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setBottomLeftBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setBottomRightBorderUV", VALUEFUNC(_wrap_BorderPanelOverlayElement_setBottomRightBorderUV), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getLeftBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getLeftBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getRightBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getRightBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getTopBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getTopBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getBottomBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getBottomBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getTopLeftBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getTopLeftBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getTopRightBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getTopRightBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getBottomLeftBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getBottomLeftBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getBottomRightBorderUVString", VALUEFUNC(_wrap_BorderPanelOverlayElement_getBottomRightBorderUVString), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setBorderMaterialName", VALUEFUNC(_wrap_BorderPanelOverlayElement_setBorderMaterialName), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "getBorderMaterialName", VALUEFUNC(_wrap_BorderPanelOverlayElement_getBorderMaterialName), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "_updateRenderQueue", VALUEFUNC(_wrap_BorderPanelOverlayElement__updateRenderQueue), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "visitRenderables", VALUEFUNC(_wrap_BorderPanelOverlayElement_visitRenderables), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "setMetricsMode", VALUEFUNC(_wrap_BorderPanelOverlayElement_setMetricsMode), -1);
  rb_define_method(SwigClassBorderPanelOverlayElement.klass, "_update", VALUEFUNC(_wrap_BorderPanelOverlayElement__update), -1);
  rb_define_singleton_method(SwigClassBorderPanelOverlayElement.klass, "cast", VALUEFUNC(_wrap_BorderPanelOverlayElement_cast), -1);
  SwigClassBorderPanelOverlayElement.mark = 0;
  SwigClassBorderPanelOverlayElement.destroy = (void (*)(void *)) free_Ogre_BorderPanelOverlayElement;
  SwigClassBorderPanelOverlayElement.trackObjects = 0;
  
  SwigClassBorderRenderable.klass = rb_define_class_under(mOgre, "BorderRenderable", ((swig_class *) SWIGTYPE_p_Ogre__Renderable->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BorderRenderable, (void *) &SwigClassBorderRenderable);
  rb_define_alloc_func(SwigClassBorderRenderable.klass, _wrap_BorderRenderable_allocate);
  rb_define_method(SwigClassBorderRenderable.klass, "initialize", VALUEFUNC(_wrap_new_BorderRenderable), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "getMaterial", VALUEFUNC(_wrap_BorderRenderable_getMaterial), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "getRenderOperation", VALUEFUNC(_wrap_BorderRenderable_getRenderOperation), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "getWorldTransforms", VALUEFUNC(_wrap_BorderRenderable_getWorldTransforms), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "getNumWorldTransforms", VALUEFUNC(_wrap_BorderRenderable_getNumWorldTransforms), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_BorderRenderable_getSquaredViewDepth), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "getLights", VALUEFUNC(_wrap_BorderRenderable_getLights), -1);
  rb_define_method(SwigClassBorderRenderable.klass, "getPolygonModeOverrideable", VALUEFUNC(_wrap_BorderRenderable_getPolygonModeOverrideable), -1);
  SwigClassBorderRenderable.mark = 0;
  SwigClassBorderRenderable.destroy = (void (*)(void *)) free_Ogre_BorderRenderable;
  SwigClassBorderRenderable.trackObjects = 0;
  rb_define_const(mOgre, "OR_DEGREE_0", SWIG_From_int(static_cast< int >(Ogre::OR_DEGREE_0)));
  rb_define_const(mOgre, "OR_DEGREE_90", SWIG_From_int(static_cast< int >(Ogre::OR_DEGREE_90)));
  rb_define_const(mOgre, "OR_DEGREE_180", SWIG_From_int(static_cast< int >(Ogre::OR_DEGREE_180)));
  rb_define_const(mOgre, "OR_DEGREE_270", SWIG_From_int(static_cast< int >(Ogre::OR_DEGREE_270)));
  rb_define_const(mOgre, "OR_PORTRAIT", SWIG_From_int(static_cast< int >(Ogre::OR_PORTRAIT)));
  rb_define_const(mOgre, "OR_LANDSCAPERIGHT", SWIG_From_int(static_cast< int >(Ogre::OR_LANDSCAPERIGHT)));
  rb_define_const(mOgre, "OR_LANDSCAPELEFT", SWIG_From_int(static_cast< int >(Ogre::OR_LANDSCAPELEFT)));
  rb_define_const(mOgre, "PT_ORTHOGRAPHIC", SWIG_From_int(static_cast< int >(Ogre::PT_ORTHOGRAPHIC)));
  rb_define_const(mOgre, "PT_PERSPECTIVE", SWIG_From_int(static_cast< int >(Ogre::PT_PERSPECTIVE)));
  rb_define_const(mOgre, "FRUSTUM_PLANE_NEAR", SWIG_From_int(static_cast< int >(Ogre::FRUSTUM_PLANE_NEAR)));
  rb_define_const(mOgre, "FRUSTUM_PLANE_FAR", SWIG_From_int(static_cast< int >(Ogre::FRUSTUM_PLANE_FAR)));
  rb_define_const(mOgre, "FRUSTUM_PLANE_LEFT", SWIG_From_int(static_cast< int >(Ogre::FRUSTUM_PLANE_LEFT)));
  rb_define_const(mOgre, "FRUSTUM_PLANE_RIGHT", SWIG_From_int(static_cast< int >(Ogre::FRUSTUM_PLANE_RIGHT)));
  rb_define_const(mOgre, "FRUSTUM_PLANE_TOP", SWIG_From_int(static_cast< int >(Ogre::FRUSTUM_PLANE_TOP)));
  rb_define_const(mOgre, "FRUSTUM_PLANE_BOTTOM", SWIG_From_int(static_cast< int >(Ogre::FRUSTUM_PLANE_BOTTOM)));
  
  SwigClassFrustum.klass = rb_define_class_under(mOgre, "Frustum", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Frustum, (void *) &SwigClassFrustum);
  rb_define_alloc_func(SwigClassFrustum.klass, _wrap_Frustum_allocate);
  rb_define_method(SwigClassFrustum.klass, "initialize", VALUEFUNC(_wrap_new_Frustum), -1);
  rb_define_method(SwigClassFrustum.klass, "setFOVy", VALUEFUNC(_wrap_Frustum_setFOVy), -1);
  rb_define_method(SwigClassFrustum.klass, "getFOVy", VALUEFUNC(_wrap_Frustum_getFOVy), -1);
  rb_define_method(SwigClassFrustum.klass, "setNearClipDistance", VALUEFUNC(_wrap_Frustum_setNearClipDistance), -1);
  rb_define_method(SwigClassFrustum.klass, "getNearClipDistance", VALUEFUNC(_wrap_Frustum_getNearClipDistance), -1);
  rb_define_method(SwigClassFrustum.klass, "setFarClipDistance", VALUEFUNC(_wrap_Frustum_setFarClipDistance), -1);
  rb_define_method(SwigClassFrustum.klass, "getFarClipDistance", VALUEFUNC(_wrap_Frustum_getFarClipDistance), -1);
  rb_define_method(SwigClassFrustum.klass, "setAspectRatio", VALUEFUNC(_wrap_Frustum_setAspectRatio), -1);
  rb_define_method(SwigClassFrustum.klass, "getAspectRatio", VALUEFUNC(_wrap_Frustum_getAspectRatio), -1);
  rb_define_method(SwigClassFrustum.klass, "setFrustumOffset", VALUEFUNC(_wrap_Frustum_setFrustumOffset), -1);
  rb_define_method(SwigClassFrustum.klass, "getFrustumOffset", VALUEFUNC(_wrap_Frustum_getFrustumOffset), -1);
  rb_define_method(SwigClassFrustum.klass, "setFocalLength", VALUEFUNC(_wrap_Frustum_setFocalLength), -1);
  rb_define_method(SwigClassFrustum.klass, "getFocalLength", VALUEFUNC(_wrap_Frustum_getFocalLength), -1);
  rb_define_method(SwigClassFrustum.klass, "setFrustumExtents", VALUEFUNC(_wrap_Frustum_setFrustumExtents), -1);
  rb_define_method(SwigClassFrustum.klass, "resetFrustumExtents", VALUEFUNC(_wrap_Frustum_resetFrustumExtents), -1);
  rb_define_method(SwigClassFrustum.klass, "getFrustumExtents", VALUEFUNC(_wrap_Frustum_getFrustumExtents), -1);
  rb_define_method(SwigClassFrustum.klass, "getProjectionMatrixRS", VALUEFUNC(_wrap_Frustum_getProjectionMatrixRS), -1);
  rb_define_method(SwigClassFrustum.klass, "getProjectionMatrixWithRSDepth", VALUEFUNC(_wrap_Frustum_getProjectionMatrixWithRSDepth), -1);
  rb_define_method(SwigClassFrustum.klass, "getProjectionMatrix", VALUEFUNC(_wrap_Frustum_getProjectionMatrix), -1);
  rb_define_method(SwigClassFrustum.klass, "getViewMatrix", VALUEFUNC(_wrap_Frustum_getViewMatrix), -1);
  rb_define_method(SwigClassFrustum.klass, "calcViewMatrixRelative", VALUEFUNC(_wrap_Frustum_calcViewMatrixRelative), -1);
  rb_define_method(SwigClassFrustum.klass, "setCustomViewMatrix", VALUEFUNC(_wrap_Frustum_setCustomViewMatrix), -1);
  rb_define_method(SwigClassFrustum.klass, "isCustomViewMatrixEnabled", VALUEFUNC(_wrap_Frustum_isCustomViewMatrixEnabled), -1);
  rb_define_method(SwigClassFrustum.klass, "setCustomProjectionMatrix", VALUEFUNC(_wrap_Frustum_setCustomProjectionMatrix), -1);
  rb_define_method(SwigClassFrustum.klass, "isCustomProjectionMatrixEnabled", VALUEFUNC(_wrap_Frustum_isCustomProjectionMatrixEnabled), -1);
  rb_define_method(SwigClassFrustum.klass, "getFrustumPlanes", VALUEFUNC(_wrap_Frustum_getFrustumPlanes), -1);
  rb_define_method(SwigClassFrustum.klass, "getFrustumPlane", VALUEFUNC(_wrap_Frustum_getFrustumPlane), -1);
  rb_define_method(SwigClassFrustum.klass, "isVisible", VALUEFUNC(_wrap_Frustum_isVisible), -1);
  rb_define_method(SwigClassFrustum.klass, "getTypeFlags", VALUEFUNC(_wrap_Frustum_getTypeFlags), -1);
  rb_define_method(SwigClassFrustum.klass, "getBoundingBox", VALUEFUNC(_wrap_Frustum_getBoundingBox), -1);
  rb_define_method(SwigClassFrustum.klass, "getBoundingRadius", VALUEFUNC(_wrap_Frustum_getBoundingRadius), -1);
  rb_define_method(SwigClassFrustum.klass, "_updateRenderQueue", VALUEFUNC(_wrap_Frustum__updateRenderQueue), -1);
  rb_define_method(SwigClassFrustum.klass, "getMovableType", VALUEFUNC(_wrap_Frustum_getMovableType), -1);
  rb_define_method(SwigClassFrustum.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_Frustum__notifyCurrentCamera), -1);
  rb_define_method(SwigClassFrustum.klass, "getMaterial", VALUEFUNC(_wrap_Frustum_getMaterial), -1);
  rb_define_method(SwigClassFrustum.klass, "getRenderOperation", VALUEFUNC(_wrap_Frustum_getRenderOperation), -1);
  rb_define_method(SwigClassFrustum.klass, "getWorldTransforms", VALUEFUNC(_wrap_Frustum_getWorldTransforms), -1);
  rb_define_method(SwigClassFrustum.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_Frustum_getSquaredViewDepth), -1);
  rb_define_method(SwigClassFrustum.klass, "getLights", VALUEFUNC(_wrap_Frustum_getLights), -1);
  rb_define_method(SwigClassFrustum.klass, "getWorldSpaceCorners", VALUEFUNC(_wrap_Frustum_getWorldSpaceCorners), -1);
  rb_define_method(SwigClassFrustum.klass, "setProjectionType", VALUEFUNC(_wrap_Frustum_setProjectionType), -1);
  rb_define_method(SwigClassFrustum.klass, "getProjectionType", VALUEFUNC(_wrap_Frustum_getProjectionType), -1);
  rb_define_method(SwigClassFrustum.klass, "setOrthoWindow", VALUEFUNC(_wrap_Frustum_setOrthoWindow), -1);
  rb_define_method(SwigClassFrustum.klass, "setOrthoWindowHeight", VALUEFUNC(_wrap_Frustum_setOrthoWindowHeight), -1);
  rb_define_method(SwigClassFrustum.klass, "setOrthoWindowWidth", VALUEFUNC(_wrap_Frustum_setOrthoWindowWidth), -1);
  rb_define_method(SwigClassFrustum.klass, "getOrthoWindowHeight", VALUEFUNC(_wrap_Frustum_getOrthoWindowHeight), -1);
  rb_define_method(SwigClassFrustum.klass, "getOrthoWindowWidth", VALUEFUNC(_wrap_Frustum_getOrthoWindowWidth), -1);
  rb_define_method(SwigClassFrustum.klass, "enableReflection", VALUEFUNC(_wrap_Frustum_enableReflection), -1);
  rb_define_method(SwigClassFrustum.klass, "disableReflection", VALUEFUNC(_wrap_Frustum_disableReflection), -1);
  rb_define_method(SwigClassFrustum.klass, "isReflected", VALUEFUNC(_wrap_Frustum_isReflected), -1);
  rb_define_method(SwigClassFrustum.klass, "getReflectionMatrix", VALUEFUNC(_wrap_Frustum_getReflectionMatrix), -1);
  rb_define_method(SwigClassFrustum.klass, "getReflectionPlane", VALUEFUNC(_wrap_Frustum_getReflectionPlane), -1);
  rb_define_method(SwigClassFrustum.klass, "projectSphere", VALUEFUNC(_wrap_Frustum_projectSphere), -1);
  rb_define_method(SwigClassFrustum.klass, "enableCustomNearClipPlane", VALUEFUNC(_wrap_Frustum_enableCustomNearClipPlane), -1);
  rb_define_method(SwigClassFrustum.klass, "disableCustomNearClipPlane", VALUEFUNC(_wrap_Frustum_disableCustomNearClipPlane), -1);
  rb_define_method(SwigClassFrustum.klass, "isCustomNearClipPlaneEnabled", VALUEFUNC(_wrap_Frustum_isCustomNearClipPlaneEnabled), -1);
  rb_define_method(SwigClassFrustum.klass, "visitRenderables", VALUEFUNC(_wrap_Frustum_visitRenderables), -1);
  rb_define_singleton_method(SwigClassFrustum.klass, "INFINITE_FAR_PLANE_ADJUST", VALUEFUNC(_wrap_Frustum_INFINITE_FAR_PLANE_ADJUST_get), 0);
  rb_define_method(SwigClassFrustum.klass, "getPositionForViewUpdate", VALUEFUNC(_wrap_Frustum_getPositionForViewUpdate), -1);
  rb_define_method(SwigClassFrustum.klass, "getOrientationForViewUpdate", VALUEFUNC(_wrap_Frustum_getOrientationForViewUpdate), -1);
  rb_define_method(SwigClassFrustum.klass, "getPlaneBoundedVolume", VALUEFUNC(_wrap_Frustum_getPlaneBoundedVolume), -1);
  rb_define_method(SwigClassFrustum.klass, "setOrientationMode", VALUEFUNC(_wrap_Frustum_setOrientationMode), -1);
  rb_define_method(SwigClassFrustum.klass, "getOrientationMode", VALUEFUNC(_wrap_Frustum_getOrientationMode), -1);
  SwigClassFrustum.mark = 0;
  SwigClassFrustum.destroy = (void (*)(void *)) free_Ogre_Frustum;
  SwigClassFrustum.trackObjects = 0;
  
  SwigClassRay.klass = rb_define_class_under(mOgre, "Ray", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Ray, (void *) &SwigClassRay);
  rb_define_alloc_func(SwigClassRay.klass, _wrap_Ray_allocate);
  rb_define_method(SwigClassRay.klass, "initialize", VALUEFUNC(_wrap_new_Ray), -1);
  rb_define_method(SwigClassRay.klass, "setOrigin", VALUEFUNC(_wrap_Ray_setOrigin), -1);
  rb_define_method(SwigClassRay.klass, "getOrigin", VALUEFUNC(_wrap_Ray_getOrigin), -1);
  rb_define_method(SwigClassRay.klass, "setDirection", VALUEFUNC(_wrap_Ray_setDirection), -1);
  rb_define_method(SwigClassRay.klass, "getDirection", VALUEFUNC(_wrap_Ray_getDirection), -1);
  rb_define_method(SwigClassRay.klass, "getPoint", VALUEFUNC(_wrap_Ray_getPoint), -1);
  rb_define_method(SwigClassRay.klass, "*", VALUEFUNC(_wrap_Ray___mul__), -1);
  rb_define_method(SwigClassRay.klass, "intersects", VALUEFUNC(_wrap_Ray_intersects), -1);
  SwigClassRay.mark = 0;
  SwigClassRay.destroy = (void (*)(void *)) free_Ogre_Ray;
  SwigClassRay.trackObjects = 0;
  
  SwigClassCamera.klass = rb_define_class_under(mOgre, "Camera", ((swig_class *) SWIGTYPE_p_Ogre__Frustum->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Camera, (void *) &SwigClassCamera);
  rb_define_alloc_func(SwigClassCamera.klass, _wrap_Camera_allocate);
  rb_define_method(SwigClassCamera.klass, "initialize", VALUEFUNC(_wrap_new_Camera), -1);
  rb_define_method(SwigClassCamera.klass, "addListener", VALUEFUNC(_wrap_Camera_addListener), -1);
  rb_define_method(SwigClassCamera.klass, "removeListener", VALUEFUNC(_wrap_Camera_removeListener), -1);
  rb_define_method(SwigClassCamera.klass, "getSceneManager", VALUEFUNC(_wrap_Camera_getSceneManager), -1);
  rb_define_method(SwigClassCamera.klass, "setPolygonMode", VALUEFUNC(_wrap_Camera_setPolygonMode), -1);
  rb_define_method(SwigClassCamera.klass, "getPolygonMode", VALUEFUNC(_wrap_Camera_getPolygonMode), -1);
  rb_define_method(SwigClassCamera.klass, "setPosition", VALUEFUNC(_wrap_Camera_setPosition), -1);
  rb_define_method(SwigClassCamera.klass, "getPosition", VALUEFUNC(_wrap_Camera_getPosition), -1);
  rb_define_method(SwigClassCamera.klass, "move", VALUEFUNC(_wrap_Camera_move), -1);
  rb_define_method(SwigClassCamera.klass, "moveRelative", VALUEFUNC(_wrap_Camera_moveRelative), -1);
  rb_define_method(SwigClassCamera.klass, "setDirection", VALUEFUNC(_wrap_Camera_setDirection), -1);
  rb_define_method(SwigClassCamera.klass, "getDirection", VALUEFUNC(_wrap_Camera_getDirection), -1);
  rb_define_method(SwigClassCamera.klass, "getUp", VALUEFUNC(_wrap_Camera_getUp), -1);
  rb_define_method(SwigClassCamera.klass, "getRight", VALUEFUNC(_wrap_Camera_getRight), -1);
  rb_define_method(SwigClassCamera.klass, "lookAt", VALUEFUNC(_wrap_Camera_lookAt), -1);
  rb_define_method(SwigClassCamera.klass, "roll", VALUEFUNC(_wrap_Camera_roll), -1);
  rb_define_method(SwigClassCamera.klass, "yaw", VALUEFUNC(_wrap_Camera_yaw), -1);
  rb_define_method(SwigClassCamera.klass, "pitch", VALUEFUNC(_wrap_Camera_pitch), -1);
  rb_define_method(SwigClassCamera.klass, "rotate", VALUEFUNC(_wrap_Camera_rotate), -1);
  rb_define_method(SwigClassCamera.klass, "setFixedYawAxis", VALUEFUNC(_wrap_Camera_setFixedYawAxis), -1);
  rb_define_method(SwigClassCamera.klass, "getOrientation", VALUEFUNC(_wrap_Camera_getOrientation), -1);
  rb_define_method(SwigClassCamera.klass, "setOrientation", VALUEFUNC(_wrap_Camera_setOrientation), -1);
  rb_define_method(SwigClassCamera.klass, "_renderScene", VALUEFUNC(_wrap_Camera__renderScene), -1);
  rb_define_method(SwigClassCamera.klass, "_notifyRenderedFaces", VALUEFUNC(_wrap_Camera__notifyRenderedFaces), -1);
  rb_define_method(SwigClassCamera.klass, "_notifyRenderedBatches", VALUEFUNC(_wrap_Camera__notifyRenderedBatches), -1);
  rb_define_method(SwigClassCamera.klass, "_getNumRenderedFaces", VALUEFUNC(_wrap_Camera__getNumRenderedFaces), -1);
  rb_define_method(SwigClassCamera.klass, "_getNumRenderedBatches", VALUEFUNC(_wrap_Camera__getNumRenderedBatches), -1);
  rb_define_method(SwigClassCamera.klass, "getDerivedOrientation", VALUEFUNC(_wrap_Camera_getDerivedOrientation), -1);
  rb_define_method(SwigClassCamera.klass, "getDerivedPosition", VALUEFUNC(_wrap_Camera_getDerivedPosition), -1);
  rb_define_method(SwigClassCamera.klass, "getDerivedDirection", VALUEFUNC(_wrap_Camera_getDerivedDirection), -1);
  rb_define_method(SwigClassCamera.klass, "getDerivedUp", VALUEFUNC(_wrap_Camera_getDerivedUp), -1);
  rb_define_method(SwigClassCamera.klass, "getDerivedRight", VALUEFUNC(_wrap_Camera_getDerivedRight), -1);
  rb_define_method(SwigClassCamera.klass, "getRealOrientation", VALUEFUNC(_wrap_Camera_getRealOrientation), -1);
  rb_define_method(SwigClassCamera.klass, "getRealPosition", VALUEFUNC(_wrap_Camera_getRealPosition), -1);
  rb_define_method(SwigClassCamera.klass, "getRealDirection", VALUEFUNC(_wrap_Camera_getRealDirection), -1);
  rb_define_method(SwigClassCamera.klass, "getRealUp", VALUEFUNC(_wrap_Camera_getRealUp), -1);
  rb_define_method(SwigClassCamera.klass, "getRealRight", VALUEFUNC(_wrap_Camera_getRealRight), -1);
  rb_define_method(SwigClassCamera.klass, "getWorldTransforms", VALUEFUNC(_wrap_Camera_getWorldTransforms), -1);
  rb_define_method(SwigClassCamera.klass, "getMovableType", VALUEFUNC(_wrap_Camera_getMovableType), -1);
  rb_define_method(SwigClassCamera.klass, "setAutoTracking", VALUEFUNC(_wrap_Camera_setAutoTracking), -1);
  rb_define_method(SwigClassCamera.klass, "setLodBias", VALUEFUNC(_wrap_Camera_setLodBias), -1);
  rb_define_method(SwigClassCamera.klass, "getLodBias", VALUEFUNC(_wrap_Camera_getLodBias), -1);
  rb_define_method(SwigClassCamera.klass, "setLodCamera", VALUEFUNC(_wrap_Camera_setLodCamera), -1);
  rb_define_method(SwigClassCamera.klass, "getLodCamera", VALUEFUNC(_wrap_Camera_getLodCamera), -1);
  rb_define_method(SwigClassCamera.klass, "getCameraToViewportRay", VALUEFUNC(_wrap_Camera_getCameraToViewportRay), -1);
  rb_define_method(SwigClassCamera.klass, "getCameraToViewportBoxVolume", VALUEFUNC(_wrap_Camera_getCameraToViewportBoxVolume), -1);
  rb_define_method(SwigClassCamera.klass, "_getLodBiasInverse", VALUEFUNC(_wrap_Camera__getLodBiasInverse), -1);
  rb_define_method(SwigClassCamera.klass, "_autoTrack", VALUEFUNC(_wrap_Camera__autoTrack), -1);
  rb_define_method(SwigClassCamera.klass, "setWindow", VALUEFUNC(_wrap_Camera_setWindow), -1);
  rb_define_method(SwigClassCamera.klass, "resetWindow", VALUEFUNC(_wrap_Camera_resetWindow), -1);
  rb_define_method(SwigClassCamera.klass, "isWindowSet", VALUEFUNC(_wrap_Camera_isWindowSet), -1);
  rb_define_method(SwigClassCamera.klass, "getWindowPlanes", VALUEFUNC(_wrap_Camera_getWindowPlanes), -1);
  rb_define_method(SwigClassCamera.klass, "getBoundingRadius", VALUEFUNC(_wrap_Camera_getBoundingRadius), -1);
  rb_define_method(SwigClassCamera.klass, "getAutoTrackTarget", VALUEFUNC(_wrap_Camera_getAutoTrackTarget), -1);
  rb_define_method(SwigClassCamera.klass, "getAutoTrackOffset", VALUEFUNC(_wrap_Camera_getAutoTrackOffset), -1);
  rb_define_method(SwigClassCamera.klass, "getViewport", VALUEFUNC(_wrap_Camera_getViewport), -1);
  rb_define_method(SwigClassCamera.klass, "_notifyViewport", VALUEFUNC(_wrap_Camera__notifyViewport), -1);
  rb_define_method(SwigClassCamera.klass, "setAutoAspectRatio", VALUEFUNC(_wrap_Camera_setAutoAspectRatio), -1);
  rb_define_method(SwigClassCamera.klass, "getAutoAspectRatio", VALUEFUNC(_wrap_Camera_getAutoAspectRatio), -1);
  rb_define_method(SwigClassCamera.klass, "setCullingFrustum", VALUEFUNC(_wrap_Camera_setCullingFrustum), -1);
  rb_define_method(SwigClassCamera.klass, "getCullingFrustum", VALUEFUNC(_wrap_Camera_getCullingFrustum), -1);
  rb_define_method(SwigClassCamera.klass, "forwardIntersect", VALUEFUNC(_wrap_Camera_forwardIntersect), -1);
  rb_define_method(SwigClassCamera.klass, "isVisible", VALUEFUNC(_wrap_Camera_isVisible), -1);
  rb_define_method(SwigClassCamera.klass, "getWorldSpaceCorners", VALUEFUNC(_wrap_Camera_getWorldSpaceCorners), -1);
  rb_define_method(SwigClassCamera.klass, "getFrustumPlane", VALUEFUNC(_wrap_Camera_getFrustumPlane), -1);
  rb_define_method(SwigClassCamera.klass, "projectSphere", VALUEFUNC(_wrap_Camera_projectSphere), -1);
  rb_define_method(SwigClassCamera.klass, "getNearClipDistance", VALUEFUNC(_wrap_Camera_getNearClipDistance), -1);
  rb_define_method(SwigClassCamera.klass, "getFarClipDistance", VALUEFUNC(_wrap_Camera_getFarClipDistance), -1);
  rb_define_method(SwigClassCamera.klass, "getViewMatrix", VALUEFUNC(_wrap_Camera_getViewMatrix), -1);
  rb_define_method(SwigClassCamera.klass, "setUseRenderingDistance", VALUEFUNC(_wrap_Camera_setUseRenderingDistance), -1);
  rb_define_method(SwigClassCamera.klass, "getUseRenderingDistance", VALUEFUNC(_wrap_Camera_getUseRenderingDistance), -1);
  rb_define_method(SwigClassCamera.klass, "synchroniseBaseSettingsWith", VALUEFUNC(_wrap_Camera_synchroniseBaseSettingsWith), -1);
  rb_define_method(SwigClassCamera.klass, "getPositionForViewUpdate", VALUEFUNC(_wrap_Camera_getPositionForViewUpdate), -1);
  rb_define_method(SwigClassCamera.klass, "getOrientationForViewUpdate", VALUEFUNC(_wrap_Camera_getOrientationForViewUpdate), -1);
  rb_define_method(SwigClassCamera.klass, "setUseMinPixelSize", VALUEFUNC(_wrap_Camera_setUseMinPixelSize), -1);
  rb_define_method(SwigClassCamera.klass, "getUseMinPixelSize", VALUEFUNC(_wrap_Camera_getUseMinPixelSize), -1);
  rb_define_method(SwigClassCamera.klass, "getPixelDisplayRatio", VALUEFUNC(_wrap_Camera_getPixelDisplayRatio), -1);
  SwigClassCamera.mark = 0;
  SwigClassCamera.destroy = (void (*)(void *)) free_Ogre_Camera;
  SwigClassCamera.trackObjects = 0;
  
  SwigClassCodec.klass = rb_define_class_under(mOgre, "Codec", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Codec, (void *) &SwigClassCodec);
  rb_undef_alloc_func(SwigClassCodec.klass);
  rb_define_singleton_method(SwigClassCodec.klass, "registerCodec", VALUEFUNC(_wrap_Codec_registerCodec), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "isCodecRegistered", VALUEFUNC(_wrap_Codec_isCodecRegistered), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "unRegisterCodec", VALUEFUNC(_wrap_Codec_unRegisterCodec), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "getCodecIterator", VALUEFUNC(_wrap_Codec_getCodecIterator), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "getExtensions", VALUEFUNC(_wrap_Codec_getExtensions), -1);
  rb_define_singleton_method(SwigClassCodec.klass, "getCodec", VALUEFUNC(_wrap_Codec_getCodec), -1);
  rb_define_method(SwigClassCodec.klass, "code", VALUEFUNC(_wrap_Codec_code), -1);
  rb_define_method(SwigClassCodec.klass, "codeToFile", VALUEFUNC(_wrap_Codec_codeToFile), -1);
  rb_define_method(SwigClassCodec.klass, "decode", VALUEFUNC(_wrap_Codec_decode), -1);
  rb_define_method(SwigClassCodec.klass, "getType", VALUEFUNC(_wrap_Codec_getType), -1);
  rb_define_method(SwigClassCodec.klass, "getDataType", VALUEFUNC(_wrap_Codec_getDataType), -1);
  rb_define_method(SwigClassCodec.klass, "magicNumberMatch", VALUEFUNC(_wrap_Codec_magicNumberMatch), -1);
  rb_define_method(SwigClassCodec.klass, "magicNumberToFileExt", VALUEFUNC(_wrap_Codec_magicNumberToFileExt), -1);
  SwigClassCodec.mark = 0;
  SwigClassCodec.destroy = (void (*)(void *)) free_Ogre_Codec;
  SwigClassCodec.trackObjects = 0;
  rb_define_const(mOgre, "PF_UNKNOWN", SWIG_From_int(static_cast< int >(Ogre::PF_UNKNOWN)));
  rb_define_const(mOgre, "PF_L8", SWIG_From_int(static_cast< int >(Ogre::PF_L8)));
  rb_define_const(mOgre, "PF_BYTE_L", SWIG_From_int(static_cast< int >(Ogre::PF_BYTE_L)));
  rb_define_const(mOgre, "PF_L16", SWIG_From_int(static_cast< int >(Ogre::PF_L16)));
  rb_define_const(mOgre, "PF_SHORT_L", SWIG_From_int(static_cast< int >(Ogre::PF_SHORT_L)));
  rb_define_const(mOgre, "PF_A8", SWIG_From_int(static_cast< int >(Ogre::PF_A8)));
  rb_define_const(mOgre, "PF_BYTE_A", SWIG_From_int(static_cast< int >(Ogre::PF_BYTE_A)));
  rb_define_const(mOgre, "PF_A4L4", SWIG_From_int(static_cast< int >(Ogre::PF_A4L4)));
  rb_define_const(mOgre, "PF_BYTE_LA", SWIG_From_int(static_cast< int >(Ogre::PF_BYTE_LA)));
  rb_define_const(mOgre, "PF_R5G6B5", SWIG_From_int(static_cast< int >(Ogre::PF_R5G6B5)));
  rb_define_const(mOgre, "PF_B5G6R5", SWIG_From_int(static_cast< int >(Ogre::PF_B5G6R5)));
  rb_define_const(mOgre, "PF_R3G3B2", SWIG_From_int(static_cast< int >(Ogre::PF_R3G3B2)));
  rb_define_const(mOgre, "PF_A4R4G4B4", SWIG_From_int(static_cast< int >(Ogre::PF_A4R4G4B4)));
  rb_define_const(mOgre, "PF_A1R5G5B5", SWIG_From_int(static_cast< int >(Ogre::PF_A1R5G5B5)));
  rb_define_const(mOgre, "PF_R8G8B8", SWIG_From_int(static_cast< int >(Ogre::PF_R8G8B8)));
  rb_define_const(mOgre, "PF_B8G8R8", SWIG_From_int(static_cast< int >(Ogre::PF_B8G8R8)));
  rb_define_const(mOgre, "PF_A8R8G8B8", SWIG_From_int(static_cast< int >(Ogre::PF_A8R8G8B8)));
  rb_define_const(mOgre, "PF_A8B8G8R8", SWIG_From_int(static_cast< int >(Ogre::PF_A8B8G8R8)));
  rb_define_const(mOgre, "PF_B8G8R8A8", SWIG_From_int(static_cast< int >(Ogre::PF_B8G8R8A8)));
  rb_define_const(mOgre, "PF_R8G8B8A8", SWIG_From_int(static_cast< int >(Ogre::PF_R8G8B8A8)));
  rb_define_const(mOgre, "PF_X8R8G8B8", SWIG_From_int(static_cast< int >(Ogre::PF_X8R8G8B8)));
  rb_define_const(mOgre, "PF_X8B8G8R8", SWIG_From_int(static_cast< int >(Ogre::PF_X8B8G8R8)));
  rb_define_const(mOgre, "PF_BYTE_RGB", SWIG_From_int(static_cast< int >(Ogre::PF_BYTE_RGB)));
  rb_define_const(mOgre, "PF_BYTE_BGR", SWIG_From_int(static_cast< int >(Ogre::PF_BYTE_BGR)));
  rb_define_const(mOgre, "PF_BYTE_BGRA", SWIG_From_int(static_cast< int >(Ogre::PF_BYTE_BGRA)));
  rb_define_const(mOgre, "PF_BYTE_RGBA", SWIG_From_int(static_cast< int >(Ogre::PF_BYTE_RGBA)));
  rb_define_const(mOgre, "PF_A2R10G10B10", SWIG_From_int(static_cast< int >(Ogre::PF_A2R10G10B10)));
  rb_define_const(mOgre, "PF_A2B10G10R10", SWIG_From_int(static_cast< int >(Ogre::PF_A2B10G10R10)));
  rb_define_const(mOgre, "PF_DXT1", SWIG_From_int(static_cast< int >(Ogre::PF_DXT1)));
  rb_define_const(mOgre, "PF_DXT2", SWIG_From_int(static_cast< int >(Ogre::PF_DXT2)));
  rb_define_const(mOgre, "PF_DXT3", SWIG_From_int(static_cast< int >(Ogre::PF_DXT3)));
  rb_define_const(mOgre, "PF_DXT4", SWIG_From_int(static_cast< int >(Ogre::PF_DXT4)));
  rb_define_const(mOgre, "PF_DXT5", SWIG_From_int(static_cast< int >(Ogre::PF_DXT5)));
  rb_define_const(mOgre, "PF_FLOAT16_R", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT16_R)));
  rb_define_const(mOgre, "PF_FLOAT16_RGB", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT16_RGB)));
  rb_define_const(mOgre, "PF_FLOAT16_RGBA", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT16_RGBA)));
  rb_define_const(mOgre, "PF_FLOAT32_R", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT32_R)));
  rb_define_const(mOgre, "PF_FLOAT32_RGB", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT32_RGB)));
  rb_define_const(mOgre, "PF_FLOAT32_RGBA", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT32_RGBA)));
  rb_define_const(mOgre, "PF_FLOAT16_GR", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT16_GR)));
  rb_define_const(mOgre, "PF_FLOAT32_GR", SWIG_From_int(static_cast< int >(Ogre::PF_FLOAT32_GR)));
  rb_define_const(mOgre, "PF_DEPTH", SWIG_From_int(static_cast< int >(Ogre::PF_DEPTH)));
  rb_define_const(mOgre, "PF_SHORT_RGBA", SWIG_From_int(static_cast< int >(Ogre::PF_SHORT_RGBA)));
  rb_define_const(mOgre, "PF_SHORT_GR", SWIG_From_int(static_cast< int >(Ogre::PF_SHORT_GR)));
  rb_define_const(mOgre, "PF_SHORT_RGB", SWIG_From_int(static_cast< int >(Ogre::PF_SHORT_RGB)));
  rb_define_const(mOgre, "PF_PVRTC_RGB2", SWIG_From_int(static_cast< int >(Ogre::PF_PVRTC_RGB2)));
  rb_define_const(mOgre, "PF_PVRTC_RGBA2", SWIG_From_int(static_cast< int >(Ogre::PF_PVRTC_RGBA2)));
  rb_define_const(mOgre, "PF_PVRTC_RGB4", SWIG_From_int(static_cast< int >(Ogre::PF_PVRTC_RGB4)));
  rb_define_const(mOgre, "PF_PVRTC_RGBA4", SWIG_From_int(static_cast< int >(Ogre::PF_PVRTC_RGBA4)));
  rb_define_const(mOgre, "PF_R8", SWIG_From_int(static_cast< int >(Ogre::PF_R8)));
  rb_define_const(mOgre, "PF_RG8", SWIG_From_int(static_cast< int >(Ogre::PF_RG8)));
  rb_define_const(mOgre, "PF_COUNT", SWIG_From_int(static_cast< int >(Ogre::PF_COUNT)));
  rb_define_const(mOgre, "PFF_HASALPHA", SWIG_From_int(static_cast< int >(Ogre::PFF_HASALPHA)));
  rb_define_const(mOgre, "PFF_COMPRESSED", SWIG_From_int(static_cast< int >(Ogre::PFF_COMPRESSED)));
  rb_define_const(mOgre, "PFF_FLOAT", SWIG_From_int(static_cast< int >(Ogre::PFF_FLOAT)));
  rb_define_const(mOgre, "PFF_DEPTH", SWIG_From_int(static_cast< int >(Ogre::PFF_DEPTH)));
  rb_define_const(mOgre, "PFF_NATIVEENDIAN", SWIG_From_int(static_cast< int >(Ogre::PFF_NATIVEENDIAN)));
  rb_define_const(mOgre, "PFF_LUMINANCE", SWIG_From_int(static_cast< int >(Ogre::PFF_LUMINANCE)));
  rb_define_const(mOgre, "PCT_BYTE", SWIG_From_int(static_cast< int >(Ogre::PCT_BYTE)));
  rb_define_const(mOgre, "PCT_SHORT", SWIG_From_int(static_cast< int >(Ogre::PCT_SHORT)));
  rb_define_const(mOgre, "PCT_FLOAT16", SWIG_From_int(static_cast< int >(Ogre::PCT_FLOAT16)));
  rb_define_const(mOgre, "PCT_FLOAT32", SWIG_From_int(static_cast< int >(Ogre::PCT_FLOAT32)));
  rb_define_const(mOgre, "PCT_COUNT", SWIG_From_int(static_cast< int >(Ogre::PCT_COUNT)));
  
  SwigClassPixelBox.klass = rb_define_class_under(mOgre, "PixelBox", ((swig_class *) SWIGTYPE_p_Ogre__Box->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PixelBox, (void *) &SwigClassPixelBox);
  rb_define_alloc_func(SwigClassPixelBox.klass, _wrap_PixelBox_allocate);
  rb_define_method(SwigClassPixelBox.klass, "initialize", VALUEFUNC(_wrap_new_PixelBox), -1);
  rb_define_method(SwigClassPixelBox.klass, "data=", VALUEFUNC(_wrap_PixelBox_data_set), -1);
  rb_define_method(SwigClassPixelBox.klass, "data", VALUEFUNC(_wrap_PixelBox_data_get), -1);
  rb_define_method(SwigClassPixelBox.klass, "format=", VALUEFUNC(_wrap_PixelBox_format_set), -1);
  rb_define_method(SwigClassPixelBox.klass, "format", VALUEFUNC(_wrap_PixelBox_format_get), -1);
  rb_define_method(SwigClassPixelBox.klass, "rowPitch=", VALUEFUNC(_wrap_PixelBox_rowPitch_set), -1);
  rb_define_method(SwigClassPixelBox.klass, "rowPitch", VALUEFUNC(_wrap_PixelBox_rowPitch_get), -1);
  rb_define_method(SwigClassPixelBox.klass, "slicePitch=", VALUEFUNC(_wrap_PixelBox_slicePitch_set), -1);
  rb_define_method(SwigClassPixelBox.klass, "slicePitch", VALUEFUNC(_wrap_PixelBox_slicePitch_get), -1);
  rb_define_method(SwigClassPixelBox.klass, "setConsecutive", VALUEFUNC(_wrap_PixelBox_setConsecutive), -1);
  rb_define_method(SwigClassPixelBox.klass, "getRowSkip", VALUEFUNC(_wrap_PixelBox_getRowSkip), -1);
  rb_define_method(SwigClassPixelBox.klass, "getSliceSkip", VALUEFUNC(_wrap_PixelBox_getSliceSkip), -1);
  rb_define_method(SwigClassPixelBox.klass, "isConsecutive", VALUEFUNC(_wrap_PixelBox_isConsecutive), -1);
  rb_define_method(SwigClassPixelBox.klass, "getConsecutiveSize", VALUEFUNC(_wrap_PixelBox_getConsecutiveSize), -1);
  rb_define_method(SwigClassPixelBox.klass, "getSubVolume", VALUEFUNC(_wrap_PixelBox_getSubVolume), -1);
  rb_define_method(SwigClassPixelBox.klass, "getColourAt", VALUEFUNC(_wrap_PixelBox_getColourAt), -1);
  rb_define_method(SwigClassPixelBox.klass, "setColourAt", VALUEFUNC(_wrap_PixelBox_setColourAt), -1);
  SwigClassPixelBox.mark = 0;
  SwigClassPixelBox.destroy = (void (*)(void *)) free_Ogre_PixelBox;
  SwigClassPixelBox.trackObjects = 0;
  
  SwigClassPixelUtil.klass = rb_define_class_under(mOgre, "PixelUtil", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PixelUtil, (void *) &SwigClassPixelUtil);
  rb_define_alloc_func(SwigClassPixelUtil.klass, _wrap_PixelUtil_allocate);
  rb_define_method(SwigClassPixelUtil.klass, "initialize", VALUEFUNC(_wrap_new_PixelUtil), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getNumElemBytes", VALUEFUNC(_wrap_PixelUtil_getNumElemBytes), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getNumElemBits", VALUEFUNC(_wrap_PixelUtil_getNumElemBits), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getMemorySize", VALUEFUNC(_wrap_PixelUtil_getMemorySize), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getFlags", VALUEFUNC(_wrap_PixelUtil_getFlags), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "hasAlpha", VALUEFUNC(_wrap_PixelUtil_hasAlpha), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "isFloatingPoint", VALUEFUNC(_wrap_PixelUtil_isFloatingPoint), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "isCompressed", VALUEFUNC(_wrap_PixelUtil_isCompressed), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "isDepth", VALUEFUNC(_wrap_PixelUtil_isDepth), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "isNativeEndian", VALUEFUNC(_wrap_PixelUtil_isNativeEndian), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "isLuminance", VALUEFUNC(_wrap_PixelUtil_isLuminance), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "isValidExtent", VALUEFUNC(_wrap_PixelUtil_isValidExtent), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getBitDepths", VALUEFUNC(_wrap_PixelUtil_getBitDepths), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getBitMasks", VALUEFUNC(_wrap_PixelUtil_getBitMasks), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getBitShifts", VALUEFUNC(_wrap_PixelUtil_getBitShifts), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getFormatName", VALUEFUNC(_wrap_PixelUtil_getFormatName), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "isAccessible", VALUEFUNC(_wrap_PixelUtil_isAccessible), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getComponentType", VALUEFUNC(_wrap_PixelUtil_getComponentType), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getComponentCount", VALUEFUNC(_wrap_PixelUtil_getComponentCount), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getFormatFromName", VALUEFUNC(_wrap_PixelUtil_getFormatFromName), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getBNFExpressionOfPixelFormats", VALUEFUNC(_wrap_PixelUtil_getBNFExpressionOfPixelFormats), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "getFormatForBitDepths", VALUEFUNC(_wrap_PixelUtil_getFormatForBitDepths), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "packColour", VALUEFUNC(_wrap_PixelUtil_packColour), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "unpackColour", VALUEFUNC(_wrap_PixelUtil_unpackColour), -1);
  rb_define_singleton_method(SwigClassPixelUtil.klass, "bulkPixelConversion", VALUEFUNC(_wrap_PixelUtil_bulkPixelConversion), -1);
  SwigClassPixelUtil.mark = 0;
  SwigClassPixelUtil.destroy = (void (*)(void *)) free_Ogre_PixelUtil;
  SwigClassPixelUtil.trackObjects = 0;
  rb_define_const(mOgre, "IF_COMPRESSED", SWIG_From_int(static_cast< int >(Ogre::IF_COMPRESSED)));
  rb_define_const(mOgre, "IF_CUBEMAP", SWIG_From_int(static_cast< int >(Ogre::IF_CUBEMAP)));
  rb_define_const(mOgre, "IF_3D_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::IF_3D_TEXTURE)));
  
  SwigClassImage.klass = rb_define_class_under(mOgre, "Image", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Image, (void *) &SwigClassImage);
  rb_define_alloc_func(SwigClassImage.klass, _wrap_Image_allocate);
  rb_define_method(SwigClassImage.klass, "initialize", VALUEFUNC(_wrap_new_Image), -1);
  rb_define_method(SwigClassImage.klass, "flipAroundY", VALUEFUNC(_wrap_Image_flipAroundY), -1);
  rb_define_method(SwigClassImage.klass, "flipAroundX", VALUEFUNC(_wrap_Image_flipAroundX), -1);
  rb_define_method(SwigClassImage.klass, "loadDynamicImage", VALUEFUNC(_wrap_Image_loadDynamicImage), -1);
  rb_define_method(SwigClassImage.klass, "loadRawData", VALUEFUNC(_wrap_Image_loadRawData), -1);
  rb_define_method(SwigClassImage.klass, "load", VALUEFUNC(_wrap_Image_load), -1);
  rb_define_method(SwigClassImage.klass, "loadTwoImagesAsRGBA", VALUEFUNC(_wrap_Image_loadTwoImagesAsRGBA), -1);
  rb_define_method(SwigClassImage.klass, "combineTwoImagesAsRGBA", VALUEFUNC(_wrap_Image_combineTwoImagesAsRGBA), -1);
  rb_define_method(SwigClassImage.klass, "save", VALUEFUNC(_wrap_Image_save), -1);
  rb_define_method(SwigClassImage.klass, "encode", VALUEFUNC(_wrap_Image_encode), -1);
  rb_define_method(SwigClassImage.klass, "getData", VALUEFUNC(_wrap_Image_getData), -1);
  rb_define_method(SwigClassImage.klass, "getSize", VALUEFUNC(_wrap_Image_getSize), -1);
  rb_define_method(SwigClassImage.klass, "getNumMipmaps", VALUEFUNC(_wrap_Image_getNumMipmaps), -1);
  rb_define_method(SwigClassImage.klass, "hasFlag", VALUEFUNC(_wrap_Image_hasFlag), -1);
  rb_define_method(SwigClassImage.klass, "getWidth", VALUEFUNC(_wrap_Image_getWidth), -1);
  rb_define_method(SwigClassImage.klass, "getHeight", VALUEFUNC(_wrap_Image_getHeight), -1);
  rb_define_method(SwigClassImage.klass, "getDepth", VALUEFUNC(_wrap_Image_getDepth), -1);
  rb_define_method(SwigClassImage.klass, "getNumFaces", VALUEFUNC(_wrap_Image_getNumFaces), -1);
  rb_define_method(SwigClassImage.klass, "getRowSpan", VALUEFUNC(_wrap_Image_getRowSpan), -1);
  rb_define_method(SwigClassImage.klass, "getFormat", VALUEFUNC(_wrap_Image_getFormat), -1);
  rb_define_method(SwigClassImage.klass, "getBPP", VALUEFUNC(_wrap_Image_getBPP), -1);
  rb_define_method(SwigClassImage.klass, "getHasAlpha", VALUEFUNC(_wrap_Image_getHasAlpha), -1);
  rb_define_singleton_method(SwigClassImage.klass, "applyGamma", VALUEFUNC(_wrap_Image_applyGamma), -1);
  rb_define_method(SwigClassImage.klass, "getColourAt", VALUEFUNC(_wrap_Image_getColourAt), -1);
  rb_define_method(SwigClassImage.klass, "setColourAt", VALUEFUNC(_wrap_Image_setColourAt), -1);
  rb_define_method(SwigClassImage.klass, "getPixelBox", VALUEFUNC(_wrap_Image_getPixelBox), -1);
  rb_define_method(SwigClassImage.klass, "freeMemory", VALUEFUNC(_wrap_Image_freeMemory), -1);
  rb_define_const(SwigClassImage.klass, "FILTER_NEAREST", SWIG_From_int(static_cast< int >(Ogre::Image::FILTER_NEAREST)));
  rb_define_const(SwigClassImage.klass, "FILTER_LINEAR", SWIG_From_int(static_cast< int >(Ogre::Image::FILTER_LINEAR)));
  rb_define_const(SwigClassImage.klass, "FILTER_BILINEAR", SWIG_From_int(static_cast< int >(Ogre::Image::FILTER_BILINEAR)));
  rb_define_const(SwigClassImage.klass, "FILTER_BOX", SWIG_From_int(static_cast< int >(Ogre::Image::FILTER_BOX)));
  rb_define_const(SwigClassImage.klass, "FILTER_TRIANGLE", SWIG_From_int(static_cast< int >(Ogre::Image::FILTER_TRIANGLE)));
  rb_define_const(SwigClassImage.klass, "FILTER_BICUBIC", SWIG_From_int(static_cast< int >(Ogre::Image::FILTER_BICUBIC)));
  rb_define_singleton_method(SwigClassImage.klass, "scale", VALUEFUNC(_wrap_Image_scale), -1);
  rb_define_method(SwigClassImage.klass, "resize", VALUEFUNC(_wrap_Image_resize), -1);
  rb_define_singleton_method(SwigClassImage.klass, "calculateSize", VALUEFUNC(_wrap_Image_calculateSize), -1);
  rb_define_singleton_method(SwigClassImage.klass, "getFileExtFromMagic", VALUEFUNC(_wrap_Image_getFileExtFromMagic), -1);
  SwigClassImage.mark = 0;
  SwigClassImage.destroy = (void (*)(void *)) free_Ogre_Image;
  SwigClassImage.trackObjects = 0;
  rb_define_const(mOgre, "TU_STATIC", SWIG_From_int(static_cast< int >(Ogre::TU_STATIC)));
  rb_define_const(mOgre, "TU_DYNAMIC", SWIG_From_int(static_cast< int >(Ogre::TU_DYNAMIC)));
  rb_define_const(mOgre, "TU_WRITE_ONLY", SWIG_From_int(static_cast< int >(Ogre::TU_WRITE_ONLY)));
  rb_define_const(mOgre, "TU_STATIC_WRITE_ONLY", SWIG_From_int(static_cast< int >(Ogre::TU_STATIC_WRITE_ONLY)));
  rb_define_const(mOgre, "TU_DYNAMIC_WRITE_ONLY", SWIG_From_int(static_cast< int >(Ogre::TU_DYNAMIC_WRITE_ONLY)));
  rb_define_const(mOgre, "TU_DYNAMIC_WRITE_ONLY_DISCARDABLE", SWIG_From_int(static_cast< int >(Ogre::TU_DYNAMIC_WRITE_ONLY_DISCARDABLE)));
  rb_define_const(mOgre, "TU_AUTOMIPMAP", SWIG_From_int(static_cast< int >(Ogre::TU_AUTOMIPMAP)));
  rb_define_const(mOgre, "TU_RENDERTARGET", SWIG_From_int(static_cast< int >(Ogre::TU_RENDERTARGET)));
  rb_define_const(mOgre, "TU_DEFAULT", SWIG_From_int(static_cast< int >(Ogre::TU_DEFAULT)));
  rb_define_const(mOgre, "TEX_TYPE_1D", SWIG_From_int(static_cast< int >(Ogre::TEX_TYPE_1D)));
  rb_define_const(mOgre, "TEX_TYPE_2D", SWIG_From_int(static_cast< int >(Ogre::TEX_TYPE_2D)));
  rb_define_const(mOgre, "TEX_TYPE_3D", SWIG_From_int(static_cast< int >(Ogre::TEX_TYPE_3D)));
  rb_define_const(mOgre, "TEX_TYPE_CUBE_MAP", SWIG_From_int(static_cast< int >(Ogre::TEX_TYPE_CUBE_MAP)));
  rb_define_const(mOgre, "TEX_TYPE_2D_ARRAY", SWIG_From_int(static_cast< int >(Ogre::TEX_TYPE_2D_ARRAY)));
  rb_define_const(mOgre, "MIP_UNLIMITED", SWIG_From_int(static_cast< int >(Ogre::MIP_UNLIMITED)));
  rb_define_const(mOgre, "MIP_DEFAULT", SWIG_From_int(static_cast< int >(Ogre::MIP_DEFAULT)));
  
  SwigClassTexture.klass = rb_define_class_under(mOgre, "Texture", ((swig_class *) SWIGTYPE_p_Ogre__Resource->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Texture, (void *) &SwigClassTexture);
  rb_undef_alloc_func(SwigClassTexture.klass);
  rb_define_method(SwigClassTexture.klass, "setTextureType", VALUEFUNC(_wrap_Texture_setTextureType), -1);
  rb_define_method(SwigClassTexture.klass, "getTextureType", VALUEFUNC(_wrap_Texture_getTextureType), -1);
  rb_define_method(SwigClassTexture.klass, "getNumMipmaps", VALUEFUNC(_wrap_Texture_getNumMipmaps), -1);
  rb_define_method(SwigClassTexture.klass, "setNumMipmaps", VALUEFUNC(_wrap_Texture_setNumMipmaps), -1);
  rb_define_method(SwigClassTexture.klass, "getMipmapsHardwareGenerated", VALUEFUNC(_wrap_Texture_getMipmapsHardwareGenerated), -1);
  rb_define_method(SwigClassTexture.klass, "getGamma", VALUEFUNC(_wrap_Texture_getGamma), -1);
  rb_define_method(SwigClassTexture.klass, "setGamma", VALUEFUNC(_wrap_Texture_setGamma), -1);
  rb_define_method(SwigClassTexture.klass, "setHardwareGammaEnabled", VALUEFUNC(_wrap_Texture_setHardwareGammaEnabled), -1);
  rb_define_method(SwigClassTexture.klass, "isHardwareGammaEnabled", VALUEFUNC(_wrap_Texture_isHardwareGammaEnabled), -1);
  rb_define_method(SwigClassTexture.klass, "setFSAA", VALUEFUNC(_wrap_Texture_setFSAA), -1);
  rb_define_method(SwigClassTexture.klass, "getFSAA", VALUEFUNC(_wrap_Texture_getFSAA), -1);
  rb_define_method(SwigClassTexture.klass, "getFSAAHint", VALUEFUNC(_wrap_Texture_getFSAAHint), -1);
  rb_define_method(SwigClassTexture.klass, "getHeight", VALUEFUNC(_wrap_Texture_getHeight), -1);
  rb_define_method(SwigClassTexture.klass, "getWidth", VALUEFUNC(_wrap_Texture_getWidth), -1);
  rb_define_method(SwigClassTexture.klass, "getDepth", VALUEFUNC(_wrap_Texture_getDepth), -1);
  rb_define_method(SwigClassTexture.klass, "getSrcHeight", VALUEFUNC(_wrap_Texture_getSrcHeight), -1);
  rb_define_method(SwigClassTexture.klass, "getSrcWidth", VALUEFUNC(_wrap_Texture_getSrcWidth), -1);
  rb_define_method(SwigClassTexture.klass, "getSrcDepth", VALUEFUNC(_wrap_Texture_getSrcDepth), -1);
  rb_define_method(SwigClassTexture.klass, "setHeight", VALUEFUNC(_wrap_Texture_setHeight), -1);
  rb_define_method(SwigClassTexture.klass, "setWidth", VALUEFUNC(_wrap_Texture_setWidth), -1);
  rb_define_method(SwigClassTexture.klass, "setDepth", VALUEFUNC(_wrap_Texture_setDepth), -1);
  rb_define_method(SwigClassTexture.klass, "getUsage", VALUEFUNC(_wrap_Texture_getUsage), -1);
  rb_define_method(SwigClassTexture.klass, "setUsage", VALUEFUNC(_wrap_Texture_setUsage), -1);
  rb_define_method(SwigClassTexture.klass, "createInternalResources", VALUEFUNC(_wrap_Texture_createInternalResources), -1);
  rb_define_method(SwigClassTexture.klass, "freeInternalResources", VALUEFUNC(_wrap_Texture_freeInternalResources), -1);
  rb_define_method(SwigClassTexture.klass, "copyToTexture", VALUEFUNC(_wrap_Texture_copyToTexture), -1);
  rb_define_method(SwigClassTexture.klass, "loadImage", VALUEFUNC(_wrap_Texture_loadImage), -1);
  rb_define_method(SwigClassTexture.klass, "loadRawData", VALUEFUNC(_wrap_Texture_loadRawData), -1);
  rb_define_method(SwigClassTexture.klass, "_loadImages", VALUEFUNC(_wrap_Texture__loadImages), -1);
  rb_define_method(SwigClassTexture.klass, "getFormat", VALUEFUNC(_wrap_Texture_getFormat), -1);
  rb_define_method(SwigClassTexture.klass, "getDesiredFormat", VALUEFUNC(_wrap_Texture_getDesiredFormat), -1);
  rb_define_method(SwigClassTexture.klass, "getSrcFormat", VALUEFUNC(_wrap_Texture_getSrcFormat), -1);
  rb_define_method(SwigClassTexture.klass, "setFormat", VALUEFUNC(_wrap_Texture_setFormat), -1);
  rb_define_method(SwigClassTexture.klass, "hasAlpha", VALUEFUNC(_wrap_Texture_hasAlpha), -1);
  rb_define_method(SwigClassTexture.klass, "setDesiredIntegerBitDepth", VALUEFUNC(_wrap_Texture_setDesiredIntegerBitDepth), -1);
  rb_define_method(SwigClassTexture.klass, "getDesiredIntegerBitDepth", VALUEFUNC(_wrap_Texture_getDesiredIntegerBitDepth), -1);
  rb_define_method(SwigClassTexture.klass, "setDesiredFloatBitDepth", VALUEFUNC(_wrap_Texture_setDesiredFloatBitDepth), -1);
  rb_define_method(SwigClassTexture.klass, "getDesiredFloatBitDepth", VALUEFUNC(_wrap_Texture_getDesiredFloatBitDepth), -1);
  rb_define_method(SwigClassTexture.klass, "setDesiredBitDepths", VALUEFUNC(_wrap_Texture_setDesiredBitDepths), -1);
  rb_define_method(SwigClassTexture.klass, "setTreatLuminanceAsAlpha", VALUEFUNC(_wrap_Texture_setTreatLuminanceAsAlpha), -1);
  rb_define_method(SwigClassTexture.klass, "getTreatLuminanceAsAlpha", VALUEFUNC(_wrap_Texture_getTreatLuminanceAsAlpha), -1);
  rb_define_method(SwigClassTexture.klass, "getNumFaces", VALUEFUNC(_wrap_Texture_getNumFaces), -1);
  rb_define_method(SwigClassTexture.klass, "getBuffer", VALUEFUNC(_wrap_Texture_getBuffer), -1);
  rb_define_method(SwigClassTexture.klass, "convertToImage", VALUEFUNC(_wrap_Texture_convertToImage), -1);
  rb_define_method(SwigClassTexture.klass, "getCustomAttribute", VALUEFUNC(_wrap_Texture_getCustomAttribute), -1);
  SwigClassTexture.mark = 0;
  SwigClassTexture.destroy = (void (*)(void *)) free_Ogre_Texture;
  SwigClassTexture.trackObjects = 0;
  
  SwigClassTexturePtr.klass = rb_define_class_under(mOgre, "TexturePtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TexturePtr, (void *) &SwigClassTexturePtr);
  rb_define_alloc_func(SwigClassTexturePtr.klass, _wrap_TexturePtr_allocate);
  rb_define_method(SwigClassTexturePtr.klass, "initialize", VALUEFUNC(_wrap_new_TexturePtr), -1);
  SwigClassTexturePtr.mark = 0;
  SwigClassTexturePtr.destroy = (void (*)(void *)) free_Ogre_TexturePtr;
  SwigClassTexturePtr.trackObjects = 0;
  
  SwigClassTextureUnitState.klass = rb_define_class_under(mOgre, "TextureUnitState", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TextureUnitState, (void *) &SwigClassTextureUnitState);
  rb_define_alloc_func(SwigClassTextureUnitState.klass, _wrap_TextureUnitState_allocate);
  rb_define_method(SwigClassTextureUnitState.klass, "initialize", VALUEFUNC(_wrap_new_TextureUnitState), -1);
  rb_define_const(SwigClassTextureUnitState.klass, "ET_ENVIRONMENT_MAP", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ET_ENVIRONMENT_MAP)));
  rb_define_const(SwigClassTextureUnitState.klass, "ET_PROJECTIVE_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ET_PROJECTIVE_TEXTURE)));
  rb_define_const(SwigClassTextureUnitState.klass, "ET_UVSCROLL", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ET_UVSCROLL)));
  rb_define_const(SwigClassTextureUnitState.klass, "ET_USCROLL", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ET_USCROLL)));
  rb_define_const(SwigClassTextureUnitState.klass, "ET_VSCROLL", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ET_VSCROLL)));
  rb_define_const(SwigClassTextureUnitState.klass, "ET_ROTATE", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ET_ROTATE)));
  rb_define_const(SwigClassTextureUnitState.klass, "ET_TRANSFORM", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ET_TRANSFORM)));
  rb_define_const(SwigClassTextureUnitState.klass, "ENV_PLANAR", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ENV_PLANAR)));
  rb_define_const(SwigClassTextureUnitState.klass, "ENV_CURVED", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ENV_CURVED)));
  rb_define_const(SwigClassTextureUnitState.klass, "ENV_REFLECTION", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ENV_REFLECTION)));
  rb_define_const(SwigClassTextureUnitState.klass, "ENV_NORMAL", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::ENV_NORMAL)));
  rb_define_const(SwigClassTextureUnitState.klass, "TT_TRANSLATE_U", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TT_TRANSLATE_U)));
  rb_define_const(SwigClassTextureUnitState.klass, "TT_TRANSLATE_V", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TT_TRANSLATE_V)));
  rb_define_const(SwigClassTextureUnitState.klass, "TT_SCALE_U", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TT_SCALE_U)));
  rb_define_const(SwigClassTextureUnitState.klass, "TT_SCALE_V", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TT_SCALE_V)));
  rb_define_const(SwigClassTextureUnitState.klass, "TT_ROTATE", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TT_ROTATE)));
  rb_define_const(SwigClassTextureUnitState.klass, "TAM_WRAP", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TAM_WRAP)));
  rb_define_const(SwigClassTextureUnitState.klass, "TAM_MIRROR", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TAM_MIRROR)));
  rb_define_const(SwigClassTextureUnitState.klass, "TAM_CLAMP", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TAM_CLAMP)));
  rb_define_const(SwigClassTextureUnitState.klass, "TAM_BORDER", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::TAM_BORDER)));
  rb_define_const(SwigClassTextureUnitState.klass, "CUBE_FRONT", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CUBE_FRONT)));
  rb_define_const(SwigClassTextureUnitState.klass, "CUBE_BACK", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CUBE_BACK)));
  rb_define_const(SwigClassTextureUnitState.klass, "CUBE_LEFT", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CUBE_LEFT)));
  rb_define_const(SwigClassTextureUnitState.klass, "CUBE_RIGHT", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CUBE_RIGHT)));
  rb_define_const(SwigClassTextureUnitState.klass, "CUBE_UP", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CUBE_UP)));
  rb_define_const(SwigClassTextureUnitState.klass, "CUBE_DOWN", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CUBE_DOWN)));
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureName", VALUEFUNC(_wrap_TextureUnitState_getTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureName", VALUEFUNC(_wrap_TextureUnitState_setTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTexture", VALUEFUNC(_wrap_TextureUnitState_setTexture), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setCubicTextureName", VALUEFUNC(_wrap_TextureUnitState_setCubicTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setCubicTexture", VALUEFUNC(_wrap_TextureUnitState_setCubicTexture), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setAnimatedTextureName", VALUEFUNC(_wrap_TextureUnitState_setAnimatedTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureDimensions", VALUEFUNC(_wrap_TextureUnitState_getTextureDimensions), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setCurrentFrame", VALUEFUNC(_wrap_TextureUnitState_setCurrentFrame), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getCurrentFrame", VALUEFUNC(_wrap_TextureUnitState_getCurrentFrame), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getFrameTextureName", VALUEFUNC(_wrap_TextureUnitState_getFrameTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setFrameTextureName", VALUEFUNC(_wrap_TextureUnitState_setFrameTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "addFrameTextureName", VALUEFUNC(_wrap_TextureUnitState_addFrameTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "deleteFrameTextureName", VALUEFUNC(_wrap_TextureUnitState_deleteFrameTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getNumFrames", VALUEFUNC(_wrap_TextureUnitState_getNumFrames), -1);
  rb_define_const(SwigClassTextureUnitState.klass, "BT_FRAGMENT", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::BT_FRAGMENT)));
  rb_define_const(SwigClassTextureUnitState.klass, "BT_VERTEX", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::BT_VERTEX)));
  rb_define_const(SwigClassTextureUnitState.klass, "CONTENT_NAMED", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CONTENT_NAMED)));
  rb_define_const(SwigClassTextureUnitState.klass, "CONTENT_SHADOW", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CONTENT_SHADOW)));
  rb_define_const(SwigClassTextureUnitState.klass, "CONTENT_COMPOSITOR", SWIG_From_int(static_cast< int >(Ogre::TextureUnitState::CONTENT_COMPOSITOR)));
  rb_define_method(SwigClassTextureUnitState.klass, "setBindingType", VALUEFUNC(_wrap_TextureUnitState_setBindingType), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getBindingType", VALUEFUNC(_wrap_TextureUnitState_getBindingType), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setContentType", VALUEFUNC(_wrap_TextureUnitState_setContentType), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getContentType", VALUEFUNC(_wrap_TextureUnitState_getContentType), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "isCubic", VALUEFUNC(_wrap_TextureUnitState_isCubic), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "is3D", VALUEFUNC(_wrap_TextureUnitState_is3D), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureType", VALUEFUNC(_wrap_TextureUnitState_getTextureType), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setDesiredFormat", VALUEFUNC(_wrap_TextureUnitState_setDesiredFormat), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getDesiredFormat", VALUEFUNC(_wrap_TextureUnitState_getDesiredFormat), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setNumMipmaps", VALUEFUNC(_wrap_TextureUnitState_setNumMipmaps), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getNumMipmaps", VALUEFUNC(_wrap_TextureUnitState_getNumMipmaps), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setIsAlpha", VALUEFUNC(_wrap_TextureUnitState_setIsAlpha), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getIsAlpha", VALUEFUNC(_wrap_TextureUnitState_getIsAlpha), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setHardwareGammaEnabled", VALUEFUNC(_wrap_TextureUnitState_setHardwareGammaEnabled), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "isHardwareGammaEnabled", VALUEFUNC(_wrap_TextureUnitState_isHardwareGammaEnabled), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureCoordSet", VALUEFUNC(_wrap_TextureUnitState_getTextureCoordSet), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureCoordSet", VALUEFUNC(_wrap_TextureUnitState_setTextureCoordSet), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureTransform", VALUEFUNC(_wrap_TextureUnitState_setTextureTransform), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureTransform", VALUEFUNC(_wrap_TextureUnitState_getTextureTransform), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureScroll", VALUEFUNC(_wrap_TextureUnitState_setTextureScroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureUScroll", VALUEFUNC(_wrap_TextureUnitState_setTextureUScroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureUScroll", VALUEFUNC(_wrap_TextureUnitState_getTextureUScroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureVScroll", VALUEFUNC(_wrap_TextureUnitState_setTextureVScroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureVScroll", VALUEFUNC(_wrap_TextureUnitState_getTextureVScroll), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureUScale", VALUEFUNC(_wrap_TextureUnitState_setTextureUScale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureUScale", VALUEFUNC(_wrap_TextureUnitState_getTextureUScale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureVScale", VALUEFUNC(_wrap_TextureUnitState_setTextureVScale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureVScale", VALUEFUNC(_wrap_TextureUnitState_getTextureVScale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureScale", VALUEFUNC(_wrap_TextureUnitState_setTextureScale), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureRotate", VALUEFUNC(_wrap_TextureUnitState_setTextureRotate), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureRotate", VALUEFUNC(_wrap_TextureUnitState_getTextureRotate), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureAddressingMode", VALUEFUNC(_wrap_TextureUnitState_getTextureAddressingMode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureAddressingMode", VALUEFUNC(_wrap_TextureUnitState_setTextureAddressingMode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureBorderColour", VALUEFUNC(_wrap_TextureUnitState_setTextureBorderColour), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureBorderColour", VALUEFUNC(_wrap_TextureUnitState_getTextureBorderColour), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setColourOperationEx", VALUEFUNC(_wrap_TextureUnitState_setColourOperationEx), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setColourOperation", VALUEFUNC(_wrap_TextureUnitState_setColourOperation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setColourOpMultipassFallback", VALUEFUNC(_wrap_TextureUnitState_setColourOpMultipassFallback), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getColourBlendMode", VALUEFUNC(_wrap_TextureUnitState_getColourBlendMode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getAlphaBlendMode", VALUEFUNC(_wrap_TextureUnitState_getAlphaBlendMode), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getColourBlendFallbackSrc", VALUEFUNC(_wrap_TextureUnitState_getColourBlendFallbackSrc), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getColourBlendFallbackDest", VALUEFUNC(_wrap_TextureUnitState_getColourBlendFallbackDest), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setAlphaOperation", VALUEFUNC(_wrap_TextureUnitState_setAlphaOperation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "addEffect", VALUEFUNC(_wrap_TextureUnitState_addEffect), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setEnvironmentMap", VALUEFUNC(_wrap_TextureUnitState_setEnvironmentMap), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setScrollAnimation", VALUEFUNC(_wrap_TextureUnitState_setScrollAnimation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setRotateAnimation", VALUEFUNC(_wrap_TextureUnitState_setRotateAnimation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTransformAnimation", VALUEFUNC(_wrap_TextureUnitState_setTransformAnimation), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setProjectiveTexturing", VALUEFUNC(_wrap_TextureUnitState_setProjectiveTexturing), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "removeAllEffects", VALUEFUNC(_wrap_TextureUnitState_removeAllEffects), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "removeEffect", VALUEFUNC(_wrap_TextureUnitState_removeEffect), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "isBlank", VALUEFUNC(_wrap_TextureUnitState_isBlank), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setBlank", VALUEFUNC(_wrap_TextureUnitState_setBlank), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "isTextureLoadFailing", VALUEFUNC(_wrap_TextureUnitState_isTextureLoadFailing), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "retryTextureLoad", VALUEFUNC(_wrap_TextureUnitState_retryTextureLoad), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getEffects", VALUEFUNC(_wrap_TextureUnitState_getEffects), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getAnimationDuration", VALUEFUNC(_wrap_TextureUnitState_getAnimationDuration), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureFiltering", VALUEFUNC(_wrap_TextureUnitState_setTextureFiltering), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureFiltering", VALUEFUNC(_wrap_TextureUnitState_getTextureFiltering), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureAnisotropy", VALUEFUNC(_wrap_TextureUnitState_setTextureAnisotropy), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureAnisotropy", VALUEFUNC(_wrap_TextureUnitState_getTextureAnisotropy), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureMipmapBias", VALUEFUNC(_wrap_TextureUnitState_setTextureMipmapBias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureMipmapBias", VALUEFUNC(_wrap_TextureUnitState_getTextureMipmapBias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setCompositorReference", VALUEFUNC(_wrap_TextureUnitState_setCompositorReference), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getReferencedCompositorName", VALUEFUNC(_wrap_TextureUnitState_getReferencedCompositorName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getReferencedTextureName", VALUEFUNC(_wrap_TextureUnitState_getReferencedTextureName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getReferencedMRTIndex", VALUEFUNC(_wrap_TextureUnitState_getReferencedMRTIndex), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getParent", VALUEFUNC(_wrap_TextureUnitState_getParent), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_prepare", VALUEFUNC(_wrap_TextureUnitState__prepare), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_unprepare", VALUEFUNC(_wrap_TextureUnitState__unprepare), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_load", VALUEFUNC(_wrap_TextureUnitState__load), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_unload", VALUEFUNC(_wrap_TextureUnitState__unload), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "hasViewRelativeTextureCoordinateGeneration", VALUEFUNC(_wrap_TextureUnitState_hasViewRelativeTextureCoordinateGeneration), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "isLoaded", VALUEFUNC(_wrap_TextureUnitState_isLoaded), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_notifyNeedsRecompile", VALUEFUNC(_wrap_TextureUnitState__notifyNeedsRecompile), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setName", VALUEFUNC(_wrap_TextureUnitState_setName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getName", VALUEFUNC(_wrap_TextureUnitState_getName), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "setTextureNameAlias", VALUEFUNC(_wrap_TextureUnitState_setTextureNameAlias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "getTextureNameAlias", VALUEFUNC(_wrap_TextureUnitState_getTextureNameAlias), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "applyTextureAliases", VALUEFUNC(_wrap_TextureUnitState_applyTextureAliases), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_notifyParent", VALUEFUNC(_wrap_TextureUnitState__notifyParent), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_getTexturePtr", VALUEFUNC(_wrap_TextureUnitState__getTexturePtr), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_setTexturePtr", VALUEFUNC(_wrap_TextureUnitState__setTexturePtr), -1);
  rb_define_method(SwigClassTextureUnitState.klass, "_getAnimController", VALUEFUNC(_wrap_TextureUnitState__getAnimController), -1);
  SwigClassTextureUnitState.mark = 0;
  SwigClassTextureUnitState.destroy = (void (*)(void *)) free_Ogre_TextureUnitState;
  SwigClassTextureUnitState.trackObjects = 0;
  rb_define_const(mOgre, "MSS_NONE", SWIG_From_int(static_cast< int >(Ogre::MSS_NONE)));
  rb_define_const(mOgre, "MSS_MATERIAL", SWIG_From_int(static_cast< int >(Ogre::MSS_MATERIAL)));
  rb_define_const(mOgre, "MSS_TECHNIQUE", SWIG_From_int(static_cast< int >(Ogre::MSS_TECHNIQUE)));
  rb_define_const(mOgre, "MSS_PASS", SWIG_From_int(static_cast< int >(Ogre::MSS_PASS)));
  rb_define_const(mOgre, "MSS_TEXTUREUNIT", SWIG_From_int(static_cast< int >(Ogre::MSS_TEXTUREUNIT)));
  rb_define_const(mOgre, "MSS_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::MSS_PROGRAM_REF)));
  rb_define_const(mOgre, "MSS_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::MSS_PROGRAM)));
  rb_define_const(mOgre, "MSS_DEFAULT_PARAMETERS", SWIG_From_int(static_cast< int >(Ogre::MSS_DEFAULT_PARAMETERS)));
  rb_define_const(mOgre, "MSS_TEXTURESOURCE", SWIG_From_int(static_cast< int >(Ogre::MSS_TEXTURESOURCE)));
  
  SwigClassMaterialScriptProgramDefinition.klass = rb_define_class_under(mOgre, "MaterialScriptProgramDefinition", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MaterialScriptProgramDefinition, (void *) &SwigClassMaterialScriptProgramDefinition);
  rb_define_alloc_func(SwigClassMaterialScriptProgramDefinition.klass, _wrap_MaterialScriptProgramDefinition_allocate);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "initialize", VALUEFUNC(_wrap_new_MaterialScriptProgramDefinition), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "name=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_name_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "name", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_name_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "progType=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_progType_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "progType", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_progType_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "language=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_language_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "language", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_language_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "source=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_source_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "source", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_source_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "syntax=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_syntax_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "syntax", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_syntax_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "supportsSkeletalAnimation=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_supportsSkeletalAnimation_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "supportsSkeletalAnimation", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_supportsSkeletalAnimation_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "supportsMorphAnimation=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_supportsMorphAnimation_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "supportsMorphAnimation", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_supportsMorphAnimation_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "supportsPoseAnimation=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_supportsPoseAnimation_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "supportsPoseAnimation", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_supportsPoseAnimation_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "usesVertexTextureFetch=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_usesVertexTextureFetch_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "usesVertexTextureFetch", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_usesVertexTextureFetch_get), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "customParameters=", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_customParameters_set), -1);
  rb_define_method(SwigClassMaterialScriptProgramDefinition.klass, "customParameters", VALUEFUNC(_wrap_MaterialScriptProgramDefinition_customParameters_get), -1);
  SwigClassMaterialScriptProgramDefinition.mark = 0;
  SwigClassMaterialScriptProgramDefinition.destroy = (void (*)(void *)) free_Ogre_MaterialScriptProgramDefinition;
  SwigClassMaterialScriptProgramDefinition.trackObjects = 0;
  
  SwigClassMaterialScriptContext.klass = rb_define_class_under(mOgre, "MaterialScriptContext", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MaterialScriptContext, (void *) &SwigClassMaterialScriptContext);
  rb_define_alloc_func(SwigClassMaterialScriptContext.klass, _wrap_MaterialScriptContext_allocate);
  rb_define_method(SwigClassMaterialScriptContext.klass, "initialize", VALUEFUNC(_wrap_new_MaterialScriptContext), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "section=", VALUEFUNC(_wrap_MaterialScriptContext_section_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "section", VALUEFUNC(_wrap_MaterialScriptContext_section_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "groupName=", VALUEFUNC(_wrap_MaterialScriptContext_groupName_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "groupName", VALUEFUNC(_wrap_MaterialScriptContext_groupName_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "material=", VALUEFUNC(_wrap_MaterialScriptContext_material_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "material", VALUEFUNC(_wrap_MaterialScriptContext_material_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "technique=", VALUEFUNC(_wrap_MaterialScriptContext_technique_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "technique", VALUEFUNC(_wrap_MaterialScriptContext_technique_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "pass=", VALUEFUNC(_wrap_MaterialScriptContext_pass_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "pass", VALUEFUNC(_wrap_MaterialScriptContext_pass_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "textureUnit=", VALUEFUNC(_wrap_MaterialScriptContext_textureUnit_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "textureUnit", VALUEFUNC(_wrap_MaterialScriptContext_textureUnit_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "program=", VALUEFUNC(_wrap_MaterialScriptContext_program_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "program", VALUEFUNC(_wrap_MaterialScriptContext_program_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isVertexProgramShadowCaster=", VALUEFUNC(_wrap_MaterialScriptContext_isVertexProgramShadowCaster_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isVertexProgramShadowCaster", VALUEFUNC(_wrap_MaterialScriptContext_isVertexProgramShadowCaster_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isFragmentProgramShadowCaster=", VALUEFUNC(_wrap_MaterialScriptContext_isFragmentProgramShadowCaster_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isFragmentProgramShadowCaster", VALUEFUNC(_wrap_MaterialScriptContext_isFragmentProgramShadowCaster_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isVertexProgramShadowReceiver=", VALUEFUNC(_wrap_MaterialScriptContext_isVertexProgramShadowReceiver_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isVertexProgramShadowReceiver", VALUEFUNC(_wrap_MaterialScriptContext_isVertexProgramShadowReceiver_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isFragmentProgramShadowReceiver=", VALUEFUNC(_wrap_MaterialScriptContext_isFragmentProgramShadowReceiver_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "isFragmentProgramShadowReceiver", VALUEFUNC(_wrap_MaterialScriptContext_isFragmentProgramShadowReceiver_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "programParams=", VALUEFUNC(_wrap_MaterialScriptContext_programParams_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "programParams", VALUEFUNC(_wrap_MaterialScriptContext_programParams_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "numAnimationParametrics=", VALUEFUNC(_wrap_MaterialScriptContext_numAnimationParametrics_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "numAnimationParametrics", VALUEFUNC(_wrap_MaterialScriptContext_numAnimationParametrics_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "programDef=", VALUEFUNC(_wrap_MaterialScriptContext_programDef_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "programDef", VALUEFUNC(_wrap_MaterialScriptContext_programDef_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "techLev=", VALUEFUNC(_wrap_MaterialScriptContext_techLev_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "techLev", VALUEFUNC(_wrap_MaterialScriptContext_techLev_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "passLev=", VALUEFUNC(_wrap_MaterialScriptContext_passLev_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "passLev", VALUEFUNC(_wrap_MaterialScriptContext_passLev_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "stateLev=", VALUEFUNC(_wrap_MaterialScriptContext_stateLev_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "stateLev", VALUEFUNC(_wrap_MaterialScriptContext_stateLev_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "defaultParamLines=", VALUEFUNC(_wrap_MaterialScriptContext_defaultParamLines_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "defaultParamLines", VALUEFUNC(_wrap_MaterialScriptContext_defaultParamLines_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "lineNo=", VALUEFUNC(_wrap_MaterialScriptContext_lineNo_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "lineNo", VALUEFUNC(_wrap_MaterialScriptContext_lineNo_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "filename=", VALUEFUNC(_wrap_MaterialScriptContext_filename_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "filename", VALUEFUNC(_wrap_MaterialScriptContext_filename_get), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "textureAliases=", VALUEFUNC(_wrap_MaterialScriptContext_textureAliases_set), -1);
  rb_define_method(SwigClassMaterialScriptContext.klass, "textureAliases", VALUEFUNC(_wrap_MaterialScriptContext_textureAliases_get), -1);
  SwigClassMaterialScriptContext.mark = 0;
  SwigClassMaterialScriptContext.destroy = (void (*)(void *)) free_Ogre_MaterialScriptContext;
  SwigClassMaterialScriptContext.trackObjects = 0;
  
  SwigClassMaterialSerializer.klass = rb_define_class_under(mOgre, "MaterialSerializer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MaterialSerializer, (void *) &SwigClassMaterialSerializer);
  rb_define_alloc_func(SwigClassMaterialSerializer.klass, _wrap_MaterialSerializer_allocate);
  rb_define_method(SwigClassMaterialSerializer.klass, "initialize", VALUEFUNC(_wrap_new_MaterialSerializer), -1);
  rb_define_const(SwigClassMaterialSerializer.klass, "MSE_PRE_WRITE", SWIG_From_int(static_cast< int >(Ogre::MaterialSerializer::MSE_PRE_WRITE)));
  rb_define_const(SwigClassMaterialSerializer.klass, "MSE_WRITE_BEGIN", SWIG_From_int(static_cast< int >(Ogre::MaterialSerializer::MSE_WRITE_BEGIN)));
  rb_define_const(SwigClassMaterialSerializer.klass, "MSE_WRITE_END", SWIG_From_int(static_cast< int >(Ogre::MaterialSerializer::MSE_WRITE_END)));
  rb_define_const(SwigClassMaterialSerializer.klass, "MSE_POST_WRITE", SWIG_From_int(static_cast< int >(Ogre::MaterialSerializer::MSE_POST_WRITE)));
  rb_define_method(SwigClassMaterialSerializer.klass, "queueForExport", VALUEFUNC(_wrap_MaterialSerializer_queueForExport), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "exportQueued", VALUEFUNC(_wrap_MaterialSerializer_exportQueued), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "exportMaterial", VALUEFUNC(_wrap_MaterialSerializer_exportMaterial), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "getQueuedAsString", VALUEFUNC(_wrap_MaterialSerializer_getQueuedAsString), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "clearQueue", VALUEFUNC(_wrap_MaterialSerializer_clearQueue), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "parseScript", VALUEFUNC(_wrap_MaterialSerializer_parseScript), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "addListener", VALUEFUNC(_wrap_MaterialSerializer_addListener), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "removeListener", VALUEFUNC(_wrap_MaterialSerializer_removeListener), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "beginSection", VALUEFUNC(_wrap_MaterialSerializer_beginSection), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "endSection", VALUEFUNC(_wrap_MaterialSerializer_endSection), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "writeAttribute", VALUEFUNC(_wrap_MaterialSerializer_writeAttribute), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "writeValue", VALUEFUNC(_wrap_MaterialSerializer_writeValue), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "quoteWord", VALUEFUNC(_wrap_MaterialSerializer_quoteWord), -1);
  rb_define_method(SwigClassMaterialSerializer.klass, "writeComment", VALUEFUNC(_wrap_MaterialSerializer_writeComment), -1);
  SwigClassMaterialSerializer.mark = 0;
  SwigClassMaterialSerializer.destroy = (void (*)(void *)) free_Ogre_MaterialSerializer;
  SwigClassMaterialSerializer.trackObjects = 0;
  
  SwigClassMaterialManager.klass = rb_define_class_under(mOgre, "MaterialManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MaterialManager, (void *) &SwigClassMaterialManager);
  rb_define_alloc_func(SwigClassMaterialManager.klass, _wrap_MaterialManager_allocate);
  rb_define_method(SwigClassMaterialManager.klass, "initialize", VALUEFUNC(_wrap_new_MaterialManager), -1);
  rb_define_singleton_method(SwigClassMaterialManager.klass, "DEFAULT_SCHEME_NAME", VALUEFUNC(_wrap_MaterialManager_DEFAULT_SCHEME_NAME_get), 0);
  rb_define_singleton_method(SwigClassMaterialManager.klass, "DEFAULT_SCHEME_NAME=", VALUEFUNC(_wrap_MaterialManager_DEFAULT_SCHEME_NAME_set), 1);
  rb_define_method(SwigClassMaterialManager.klass, "initialise", VALUEFUNC(_wrap_MaterialManager_initialise), -1);
  rb_define_method(SwigClassMaterialManager.klass, "parseScript", VALUEFUNC(_wrap_MaterialManager_parseScript), -1);
  rb_define_method(SwigClassMaterialManager.klass, "setDefaultTextureFiltering", VALUEFUNC(_wrap_MaterialManager_setDefaultTextureFiltering), -1);
  rb_define_method(SwigClassMaterialManager.klass, "getDefaultTextureFiltering", VALUEFUNC(_wrap_MaterialManager_getDefaultTextureFiltering), -1);
  rb_define_method(SwigClassMaterialManager.klass, "setDefaultAnisotropy", VALUEFUNC(_wrap_MaterialManager_setDefaultAnisotropy), -1);
  rb_define_method(SwigClassMaterialManager.klass, "getDefaultAnisotropy", VALUEFUNC(_wrap_MaterialManager_getDefaultAnisotropy), -1);
  rb_define_method(SwigClassMaterialManager.klass, "getDefaultSettings", VALUEFUNC(_wrap_MaterialManager_getDefaultSettings), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_getSchemeIndex", VALUEFUNC(_wrap_MaterialManager__getSchemeIndex), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_getSchemeName", VALUEFUNC(_wrap_MaterialManager__getSchemeName), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_getActiveSchemeIndex", VALUEFUNC(_wrap_MaterialManager__getActiveSchemeIndex), -1);
  rb_define_method(SwigClassMaterialManager.klass, "getActiveScheme", VALUEFUNC(_wrap_MaterialManager_getActiveScheme), -1);
  rb_define_method(SwigClassMaterialManager.klass, "setActiveScheme", VALUEFUNC(_wrap_MaterialManager_setActiveScheme), -1);
  rb_define_method(SwigClassMaterialManager.klass, "addListener", VALUEFUNC(_wrap_MaterialManager_addListener), -1);
  rb_define_method(SwigClassMaterialManager.klass, "removeListener", VALUEFUNC(_wrap_MaterialManager_removeListener), -1);
  rb_define_method(SwigClassMaterialManager.klass, "_arbitrateMissingTechniqueForActiveScheme", VALUEFUNC(_wrap_MaterialManager__arbitrateMissingTechniqueForActiveScheme), -1);
  rb_define_singleton_method(SwigClassMaterialManager.klass, "getSingleton", VALUEFUNC(_wrap_MaterialManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassMaterialManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_MaterialManager_getSingletonPtr), -1);
  SwigClassMaterialManager.mark = 0;
  SwigClassMaterialManager.destroy = (void (*)(void *)) free_Ogre_MaterialManager;
  SwigClassMaterialManager.trackObjects = 0;
  
  SwigClassStringConverter.klass = rb_define_class_under(mOgre, "StringConverter", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__StringConverter, (void *) &SwigClassStringConverter);
  rb_define_alloc_func(SwigClassStringConverter.klass, _wrap_StringConverter_allocate);
  rb_define_method(SwigClassStringConverter.klass, "initialize", VALUEFUNC(_wrap_new_StringConverter), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "toString", VALUEFUNC(_wrap_StringConverter_toString), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseReal", VALUEFUNC(_wrap_StringConverter_parseReal), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseAngle", VALUEFUNC(_wrap_StringConverter_parseAngle), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseInt", VALUEFUNC(_wrap_StringConverter_parseInt), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseUnsignedInt", VALUEFUNC(_wrap_StringConverter_parseUnsignedInt), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseLong", VALUEFUNC(_wrap_StringConverter_parseLong), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseUnsignedLong", VALUEFUNC(_wrap_StringConverter_parseUnsignedLong), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseBool", VALUEFUNC(_wrap_StringConverter_parseBool), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseVector2", VALUEFUNC(_wrap_StringConverter_parseVector2), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseVector3", VALUEFUNC(_wrap_StringConverter_parseVector3), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseVector4", VALUEFUNC(_wrap_StringConverter_parseVector4), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseMatrix3", VALUEFUNC(_wrap_StringConverter_parseMatrix3), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseMatrix4", VALUEFUNC(_wrap_StringConverter_parseMatrix4), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseQuaternion", VALUEFUNC(_wrap_StringConverter_parseQuaternion), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseColourValue", VALUEFUNC(_wrap_StringConverter_parseColourValue), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "parseStringVector", VALUEFUNC(_wrap_StringConverter_parseStringVector), -1);
  rb_define_singleton_method(SwigClassStringConverter.klass, "isNumber", VALUEFUNC(_wrap_StringConverter_isNumber), -1);
  SwigClassStringConverter.mark = 0;
  SwigClassStringConverter.destroy = (void (*)(void *)) free_Ogre_StringConverter;
  SwigClassStringConverter.trackObjects = 0;
  rb_define_const(mOgre, "OGRE_LOG_THRESHOLD", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "LL_LOW", SWIG_From_int(static_cast< int >(Ogre::LL_LOW)));
  rb_define_const(mOgre, "LL_NORMAL", SWIG_From_int(static_cast< int >(Ogre::LL_NORMAL)));
  rb_define_const(mOgre, "LL_BOREME", SWIG_From_int(static_cast< int >(Ogre::LL_BOREME)));
  rb_define_const(mOgre, "LML_TRIVIAL", SWIG_From_int(static_cast< int >(Ogre::LML_TRIVIAL)));
  rb_define_const(mOgre, "LML_NORMAL", SWIG_From_int(static_cast< int >(Ogre::LML_NORMAL)));
  rb_define_const(mOgre, "LML_CRITICAL", SWIG_From_int(static_cast< int >(Ogre::LML_CRITICAL)));
  
  SwigClassLogListener.klass = rb_define_class_under(mOgre, "LogListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LogListener, (void *) &SwigClassLogListener);
  rb_undef_alloc_func(SwigClassLogListener.klass);
  rb_define_method(SwigClassLogListener.klass, "messageLogged", VALUEFUNC(_wrap_LogListener_messageLogged), -1);
  SwigClassLogListener.mark = 0;
  SwigClassLogListener.destroy = (void (*)(void *)) free_Ogre_LogListener;
  SwigClassLogListener.trackObjects = 0;
  
  SwigClassLog.klass = rb_define_class_under(mOgre, "Log", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Log, (void *) &SwigClassLog);
  rb_define_alloc_func(SwigClassLog.klass, _wrap_Log_allocate);
  rb_define_method(SwigClassLog.klass, "initialize", VALUEFUNC(_wrap_new_Log), -1);
  rb_define_method(SwigClassLog.klass, "getName", VALUEFUNC(_wrap_Log_getName), -1);
  rb_define_method(SwigClassLog.klass, "isDebugOutputEnabled", VALUEFUNC(_wrap_Log_isDebugOutputEnabled), -1);
  rb_define_method(SwigClassLog.klass, "isFileOutputSuppressed", VALUEFUNC(_wrap_Log_isFileOutputSuppressed), -1);
  rb_define_method(SwigClassLog.klass, "isTimeStampEnabled", VALUEFUNC(_wrap_Log_isTimeStampEnabled), -1);
  rb_define_method(SwigClassLog.klass, "logMessage", VALUEFUNC(_wrap_Log_logMessage), -1);
  rb_define_method(SwigClassLog.klass, "stream", VALUEFUNC(_wrap_Log_stream), -1);
  rb_define_method(SwigClassLog.klass, "setDebugOutputEnabled", VALUEFUNC(_wrap_Log_setDebugOutputEnabled), -1);
  rb_define_method(SwigClassLog.klass, "setLogDetail", VALUEFUNC(_wrap_Log_setLogDetail), -1);
  rb_define_method(SwigClassLog.klass, "setTimeStampEnabled", VALUEFUNC(_wrap_Log_setTimeStampEnabled), -1);
  rb_define_method(SwigClassLog.klass, "getLogDetail", VALUEFUNC(_wrap_Log_getLogDetail), -1);
  rb_define_method(SwigClassLog.klass, "addListener", VALUEFUNC(_wrap_Log_addListener), -1);
  rb_define_method(SwigClassLog.klass, "removeListener", VALUEFUNC(_wrap_Log_removeListener), -1);
  SwigClassLog.mark = 0;
  SwigClassLog.destroy = (void (*)(void *)) free_Ogre_Log;
  SwigClassLog.trackObjects = 0;
  
  SwigClassLogManager.klass = rb_define_class_under(mOgre, "LogManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LogManager, (void *) &SwigClassLogManager);
  rb_define_alloc_func(SwigClassLogManager.klass, _wrap_LogManager_allocate);
  rb_define_method(SwigClassLogManager.klass, "initialize", VALUEFUNC(_wrap_new_LogManager), -1);
  rb_define_method(SwigClassLogManager.klass, "createLog", VALUEFUNC(_wrap_LogManager_createLog), -1);
  rb_define_method(SwigClassLogManager.klass, "getLog", VALUEFUNC(_wrap_LogManager_getLog), -1);
  rb_define_method(SwigClassLogManager.klass, "getDefaultLog", VALUEFUNC(_wrap_LogManager_getDefaultLog), -1);
  rb_define_method(SwigClassLogManager.klass, "destroyLog", VALUEFUNC(_wrap_LogManager_destroyLog), -1);
  rb_define_method(SwigClassLogManager.klass, "setDefaultLog", VALUEFUNC(_wrap_LogManager_setDefaultLog), -1);
  rb_define_method(SwigClassLogManager.klass, "logMessage", VALUEFUNC(_wrap_LogManager_logMessage), -1);
  rb_define_method(SwigClassLogManager.klass, "stream", VALUEFUNC(_wrap_LogManager_stream), -1);
  rb_define_method(SwigClassLogManager.klass, "setLogDetail", VALUEFUNC(_wrap_LogManager_setLogDetail), -1);
  rb_define_singleton_method(SwigClassLogManager.klass, "getSingleton", VALUEFUNC(_wrap_LogManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassLogManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_LogManager_getSingletonPtr), -1);
  SwigClassLogManager.mark = 0;
  SwigClassLogManager.destroy = (void (*)(void *)) free_Ogre_LogManager;
  SwigClassLogManager.trackObjects = 0;
  rb_define_const(mOgre, "CAPS_CATEGORY_SIZE", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_CAPS_BITSHIFT", SWIG_From_int(static_cast< int >((32-4))));
  rb_define_const(mOgre, "CAPS_CATEGORY_MASK", SWIG_From_int(static_cast< int >((((1 << 4) -1) << (32-4)))));
  rb_define_const(mOgre, "CAPS_CATEGORY_COMMON", SWIG_From_int(static_cast< int >(Ogre::CAPS_CATEGORY_COMMON)));
  rb_define_const(mOgre, "CAPS_CATEGORY_COMMON_2", SWIG_From_int(static_cast< int >(Ogre::CAPS_CATEGORY_COMMON_2)));
  rb_define_const(mOgre, "CAPS_CATEGORY_D3D9", SWIG_From_int(static_cast< int >(Ogre::CAPS_CATEGORY_D3D9)));
  rb_define_const(mOgre, "CAPS_CATEGORY_GL", SWIG_From_int(static_cast< int >(Ogre::CAPS_CATEGORY_GL)));
  rb_define_const(mOgre, "CAPS_CATEGORY_COUNT", SWIG_From_int(static_cast< int >(Ogre::CAPS_CATEGORY_COUNT)));
  rb_define_const(mOgre, "RSC_AUTOMIPMAP", SWIG_From_int(static_cast< int >(Ogre::RSC_AUTOMIPMAP)));
  rb_define_const(mOgre, "RSC_BLENDING", SWIG_From_int(static_cast< int >(Ogre::RSC_BLENDING)));
  rb_define_const(mOgre, "RSC_ANISOTROPY", SWIG_From_int(static_cast< int >(Ogre::RSC_ANISOTROPY)));
  rb_define_const(mOgre, "RSC_DOT3", SWIG_From_int(static_cast< int >(Ogre::RSC_DOT3)));
  rb_define_const(mOgre, "RSC_CUBEMAPPING", SWIG_From_int(static_cast< int >(Ogre::RSC_CUBEMAPPING)));
  rb_define_const(mOgre, "RSC_HWSTENCIL", SWIG_From_int(static_cast< int >(Ogre::RSC_HWSTENCIL)));
  rb_define_const(mOgre, "RSC_VBO", SWIG_From_int(static_cast< int >(Ogre::RSC_VBO)));
  rb_define_const(mOgre, "RSC_VERTEX_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::RSC_VERTEX_PROGRAM)));
  rb_define_const(mOgre, "RSC_FRAGMENT_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::RSC_FRAGMENT_PROGRAM)));
  rb_define_const(mOgre, "RSC_SCISSOR_TEST", SWIG_From_int(static_cast< int >(Ogre::RSC_SCISSOR_TEST)));
  rb_define_const(mOgre, "RSC_TWO_SIDED_STENCIL", SWIG_From_int(static_cast< int >(Ogre::RSC_TWO_SIDED_STENCIL)));
  rb_define_const(mOgre, "RSC_STENCIL_WRAP", SWIG_From_int(static_cast< int >(Ogre::RSC_STENCIL_WRAP)));
  rb_define_const(mOgre, "RSC_HWOCCLUSION", SWIG_From_int(static_cast< int >(Ogre::RSC_HWOCCLUSION)));
  rb_define_const(mOgre, "RSC_USER_CLIP_PLANES", SWIG_From_int(static_cast< int >(Ogre::RSC_USER_CLIP_PLANES)));
  rb_define_const(mOgre, "RSC_VERTEX_FORMAT_UBYTE4", SWIG_From_int(static_cast< int >(Ogre::RSC_VERTEX_FORMAT_UBYTE4)));
  rb_define_const(mOgre, "RSC_INFINITE_FAR_PLANE", SWIG_From_int(static_cast< int >(Ogre::RSC_INFINITE_FAR_PLANE)));
  rb_define_const(mOgre, "RSC_HWRENDER_TO_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::RSC_HWRENDER_TO_TEXTURE)));
  rb_define_const(mOgre, "RSC_TEXTURE_FLOAT", SWIG_From_int(static_cast< int >(Ogre::RSC_TEXTURE_FLOAT)));
  rb_define_const(mOgre, "RSC_NON_POWER_OF_2_TEXTURES", SWIG_From_int(static_cast< int >(Ogre::RSC_NON_POWER_OF_2_TEXTURES)));
  rb_define_const(mOgre, "RSC_TEXTURE_3D", SWIG_From_int(static_cast< int >(Ogre::RSC_TEXTURE_3D)));
  rb_define_const(mOgre, "RSC_POINT_SPRITES", SWIG_From_int(static_cast< int >(Ogre::RSC_POINT_SPRITES)));
  rb_define_const(mOgre, "RSC_POINT_EXTENDED_PARAMETERS", SWIG_From_int(static_cast< int >(Ogre::RSC_POINT_EXTENDED_PARAMETERS)));
  rb_define_const(mOgre, "RSC_VERTEX_TEXTURE_FETCH", SWIG_From_int(static_cast< int >(Ogre::RSC_VERTEX_TEXTURE_FETCH)));
  rb_define_const(mOgre, "RSC_MIPMAP_LOD_BIAS", SWIG_From_int(static_cast< int >(Ogre::RSC_MIPMAP_LOD_BIAS)));
  rb_define_const(mOgre, "RSC_GEOMETRY_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::RSC_GEOMETRY_PROGRAM)));
  rb_define_const(mOgre, "RSC_HWRENDER_TO_VERTEX_BUFFER", SWIG_From_int(static_cast< int >(Ogre::RSC_HWRENDER_TO_VERTEX_BUFFER)));
  rb_define_const(mOgre, "RSC_TEXTURE_COMPRESSION", SWIG_From_int(static_cast< int >(Ogre::RSC_TEXTURE_COMPRESSION)));
  rb_define_const(mOgre, "RSC_TEXTURE_COMPRESSION_DXT", SWIG_From_int(static_cast< int >(Ogre::RSC_TEXTURE_COMPRESSION_DXT)));
  rb_define_const(mOgre, "RSC_TEXTURE_COMPRESSION_VTC", SWIG_From_int(static_cast< int >(Ogre::RSC_TEXTURE_COMPRESSION_VTC)));
  rb_define_const(mOgre, "RSC_TEXTURE_COMPRESSION_PVRTC", SWIG_From_int(static_cast< int >(Ogre::RSC_TEXTURE_COMPRESSION_PVRTC)));
  rb_define_const(mOgre, "RSC_FIXED_FUNCTION", SWIG_From_int(static_cast< int >(Ogre::RSC_FIXED_FUNCTION)));
  rb_define_const(mOgre, "RSC_MRT_DIFFERENT_BIT_DEPTHS", SWIG_From_int(static_cast< int >(Ogre::RSC_MRT_DIFFERENT_BIT_DEPTHS)));
  rb_define_const(mOgre, "RSC_ALPHA_TO_COVERAGE", SWIG_From_int(static_cast< int >(Ogre::RSC_ALPHA_TO_COVERAGE)));
  rb_define_const(mOgre, "RSC_ADVANCED_BLEND_OPERATIONS", SWIG_From_int(static_cast< int >(Ogre::RSC_ADVANCED_BLEND_OPERATIONS)));
  rb_define_const(mOgre, "RSC_RTT_SEPARATE_DEPTHBUFFER", SWIG_From_int(static_cast< int >(Ogre::RSC_RTT_SEPARATE_DEPTHBUFFER)));
  rb_define_const(mOgre, "RSC_RTT_MAIN_DEPTHBUFFER_ATTACHABLE", SWIG_From_int(static_cast< int >(Ogre::RSC_RTT_MAIN_DEPTHBUFFER_ATTACHABLE)));
  rb_define_const(mOgre, "RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL", SWIG_From_int(static_cast< int >(Ogre::RSC_RTT_DEPTHBUFFER_RESOLUTION_LESSEQUAL)));
  rb_define_const(mOgre, "RSC_VERTEX_BUFFER_INSTANCE_DATA", SWIG_From_int(static_cast< int >(Ogre::RSC_VERTEX_BUFFER_INSTANCE_DATA)));
  rb_define_const(mOgre, "RSC_CAN_GET_COMPILED_SHADER_BUFFER", SWIG_From_int(static_cast< int >(Ogre::RSC_CAN_GET_COMPILED_SHADER_BUFFER)));
  rb_define_const(mOgre, "RSC_PERSTAGECONSTANT", SWIG_From_int(static_cast< int >(Ogre::RSC_PERSTAGECONSTANT)));
  rb_define_const(mOgre, "RSC_GL1_5_NOVBO", SWIG_From_int(static_cast< int >(Ogre::RSC_GL1_5_NOVBO)));
  rb_define_const(mOgre, "RSC_FBO", SWIG_From_int(static_cast< int >(Ogre::RSC_FBO)));
  rb_define_const(mOgre, "RSC_FBO_ARB", SWIG_From_int(static_cast< int >(Ogre::RSC_FBO_ARB)));
  rb_define_const(mOgre, "RSC_FBO_ATI", SWIG_From_int(static_cast< int >(Ogre::RSC_FBO_ATI)));
  rb_define_const(mOgre, "RSC_PBUFFER", SWIG_From_int(static_cast< int >(Ogre::RSC_PBUFFER)));
  rb_define_const(mOgre, "RSC_GL1_5_NOHWOCCLUSION", SWIG_From_int(static_cast< int >(Ogre::RSC_GL1_5_NOHWOCCLUSION)));
  rb_define_const(mOgre, "RSC_POINT_EXTENDED_PARAMETERS_ARB", SWIG_From_int(static_cast< int >(Ogre::RSC_POINT_EXTENDED_PARAMETERS_ARB)));
  rb_define_const(mOgre, "RSC_POINT_EXTENDED_PARAMETERS_EXT", SWIG_From_int(static_cast< int >(Ogre::RSC_POINT_EXTENDED_PARAMETERS_EXT)));
  rb_define_const(mOgre, "RSC_SEPARATE_SHADER_OBJECTS", SWIG_From_int(static_cast< int >(Ogre::RSC_SEPARATE_SHADER_OBJECTS)));
  
  SwigClassDriverVersion.klass = rb_define_class_under(mOgre, "DriverVersion", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DriverVersion, (void *) &SwigClassDriverVersion);
  rb_define_alloc_func(SwigClassDriverVersion.klass, _wrap_DriverVersion_allocate);
  rb_define_method(SwigClassDriverVersion.klass, "initialize", VALUEFUNC(_wrap_new_DriverVersion), -1);
  rb_define_method(SwigClassDriverVersion.klass, "major=", VALUEFUNC(_wrap_DriverVersion_major_set), -1);
  rb_define_method(SwigClassDriverVersion.klass, "major", VALUEFUNC(_wrap_DriverVersion_major_get), -1);
  rb_define_method(SwigClassDriverVersion.klass, "minor=", VALUEFUNC(_wrap_DriverVersion_minor_set), -1);
  rb_define_method(SwigClassDriverVersion.klass, "minor", VALUEFUNC(_wrap_DriverVersion_minor_get), -1);
  rb_define_method(SwigClassDriverVersion.klass, "release=", VALUEFUNC(_wrap_DriverVersion_release_set), -1);
  rb_define_method(SwigClassDriverVersion.klass, "release", VALUEFUNC(_wrap_DriverVersion_release_get), -1);
  rb_define_method(SwigClassDriverVersion.klass, "build=", VALUEFUNC(_wrap_DriverVersion_build_set), -1);
  rb_define_method(SwigClassDriverVersion.klass, "build", VALUEFUNC(_wrap_DriverVersion_build_get), -1);
  rb_define_method(SwigClassDriverVersion.klass, "toString", VALUEFUNC(_wrap_DriverVersion_toString), -1);
  rb_define_method(SwigClassDriverVersion.klass, "fromString", VALUEFUNC(_wrap_DriverVersion_fromString), -1);
  SwigClassDriverVersion.mark = 0;
  SwigClassDriverVersion.destroy = (void (*)(void *)) free_Ogre_DriverVersion;
  SwigClassDriverVersion.trackObjects = 0;
  rb_define_const(mOgre, "GPU_UNKNOWN", SWIG_From_int(static_cast< int >(Ogre::GPU_UNKNOWN)));
  rb_define_const(mOgre, "GPU_NVIDIA", SWIG_From_int(static_cast< int >(Ogre::GPU_NVIDIA)));
  rb_define_const(mOgre, "GPU_ATI", SWIG_From_int(static_cast< int >(Ogre::GPU_ATI)));
  rb_define_const(mOgre, "GPU_INTEL", SWIG_From_int(static_cast< int >(Ogre::GPU_INTEL)));
  rb_define_const(mOgre, "GPU_S3", SWIG_From_int(static_cast< int >(Ogre::GPU_S3)));
  rb_define_const(mOgre, "GPU_MATROX", SWIG_From_int(static_cast< int >(Ogre::GPU_MATROX)));
  rb_define_const(mOgre, "GPU_3DLABS", SWIG_From_int(static_cast< int >(Ogre::GPU_3DLABS)));
  rb_define_const(mOgre, "GPU_SIS", SWIG_From_int(static_cast< int >(Ogre::GPU_SIS)));
  rb_define_const(mOgre, "GPU_IMAGINATION_TECHNOLOGIES", SWIG_From_int(static_cast< int >(Ogre::GPU_IMAGINATION_TECHNOLOGIES)));
  rb_define_const(mOgre, "GPU_APPLE", SWIG_From_int(static_cast< int >(Ogre::GPU_APPLE)));
  rb_define_const(mOgre, "GPU_NOKIA", SWIG_From_int(static_cast< int >(Ogre::GPU_NOKIA)));
  rb_define_const(mOgre, "GPU_MS_SOFTWARE", SWIG_From_int(static_cast< int >(Ogre::GPU_MS_SOFTWARE)));
  rb_define_const(mOgre, "GPU_MS_WARP", SWIG_From_int(static_cast< int >(Ogre::GPU_MS_WARP)));
  rb_define_const(mOgre, "GPU_VENDOR_COUNT", SWIG_From_int(static_cast< int >(Ogre::GPU_VENDOR_COUNT)));
  
  SwigClassRenderSystemCapabilities.klass = rb_define_class_under(mOgre, "RenderSystemCapabilities", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderSystemCapabilities, (void *) &SwigClassRenderSystemCapabilities);
  rb_define_alloc_func(SwigClassRenderSystemCapabilities.klass, _wrap_RenderSystemCapabilities_allocate);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "initialize", VALUEFUNC(_wrap_new_RenderSystemCapabilities), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "calculateSize", VALUEFUNC(_wrap_RenderSystemCapabilities_calculateSize), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setDriverVersion", VALUEFUNC(_wrap_RenderSystemCapabilities_setDriverVersion), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "parseDriverVersionFromString", VALUEFUNC(_wrap_RenderSystemCapabilities_parseDriverVersionFromString), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getDriverVersion", VALUEFUNC(_wrap_RenderSystemCapabilities_getDriverVersion), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getVendor", VALUEFUNC(_wrap_RenderSystemCapabilities_getVendor), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setVendor", VALUEFUNC(_wrap_RenderSystemCapabilities_setVendor), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "parseVendorFromString", VALUEFUNC(_wrap_RenderSystemCapabilities_parseVendorFromString), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilities.klass, "vendorFromString", VALUEFUNC(_wrap_RenderSystemCapabilities_vendorFromString), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilities.klass, "vendorToString", VALUEFUNC(_wrap_RenderSystemCapabilities_vendorToString), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "isDriverOlderThanVersion", VALUEFUNC(_wrap_RenderSystemCapabilities_isDriverOlderThanVersion), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setNumWorldMatrices", VALUEFUNC(_wrap_RenderSystemCapabilities_setNumWorldMatrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setNumTextureUnits", VALUEFUNC(_wrap_RenderSystemCapabilities_setNumTextureUnits), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setStencilBufferBitDepth", VALUEFUNC(_wrap_RenderSystemCapabilities_setStencilBufferBitDepth), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setNumVertexBlendMatrices", VALUEFUNC(_wrap_RenderSystemCapabilities_setNumVertexBlendMatrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setNumMultiRenderTargets", VALUEFUNC(_wrap_RenderSystemCapabilities_setNumMultiRenderTargets), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getNumWorldMatrices", VALUEFUNC(_wrap_RenderSystemCapabilities_getNumWorldMatrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getNumTextureUnits", VALUEFUNC(_wrap_RenderSystemCapabilities_getNumTextureUnits), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getStencilBufferBitDepth", VALUEFUNC(_wrap_RenderSystemCapabilities_getStencilBufferBitDepth), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getNumVertexBlendMatrices", VALUEFUNC(_wrap_RenderSystemCapabilities_getNumVertexBlendMatrices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getNumMultiRenderTargets", VALUEFUNC(_wrap_RenderSystemCapabilities_getNumMultiRenderTargets), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "isCapabilityRenderSystemSpecific", VALUEFUNC(_wrap_RenderSystemCapabilities_isCapabilityRenderSystemSpecific), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setCapability", VALUEFUNC(_wrap_RenderSystemCapabilities_setCapability), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "unsetCapability", VALUEFUNC(_wrap_RenderSystemCapabilities_unsetCapability), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "hasCapability", VALUEFUNC(_wrap_RenderSystemCapabilities_hasCapability), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "addShaderProfile", VALUEFUNC(_wrap_RenderSystemCapabilities_addShaderProfile), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "removeShaderProfile", VALUEFUNC(_wrap_RenderSystemCapabilities_removeShaderProfile), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "isShaderProfileSupported", VALUEFUNC(_wrap_RenderSystemCapabilities_isShaderProfileSupported), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getSupportedShaderProfiles", VALUEFUNC(_wrap_RenderSystemCapabilities_getSupportedShaderProfiles), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getVertexProgramConstantFloatCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getVertexProgramConstantFloatCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getVertexProgramConstantIntCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getVertexProgramConstantIntCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getVertexProgramConstantBoolCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getVertexProgramConstantBoolCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getGeometryProgramConstantFloatCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getGeometryProgramConstantFloatCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getGeometryProgramConstantIntCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getGeometryProgramConstantIntCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getGeometryProgramConstantBoolCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getGeometryProgramConstantBoolCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getFragmentProgramConstantFloatCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getFragmentProgramConstantFloatCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getFragmentProgramConstantIntCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getFragmentProgramConstantIntCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getFragmentProgramConstantBoolCount", VALUEFUNC(_wrap_RenderSystemCapabilities_getFragmentProgramConstantBoolCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setDeviceName", VALUEFUNC(_wrap_RenderSystemCapabilities_setDeviceName), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getDeviceName", VALUEFUNC(_wrap_RenderSystemCapabilities_getDeviceName), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setVertexProgramConstantFloatCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setVertexProgramConstantFloatCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setVertexProgramConstantIntCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setVertexProgramConstantIntCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setVertexProgramConstantBoolCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setVertexProgramConstantBoolCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setGeometryProgramConstantFloatCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setGeometryProgramConstantFloatCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setGeometryProgramConstantIntCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setGeometryProgramConstantIntCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setGeometryProgramConstantBoolCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setGeometryProgramConstantBoolCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setFragmentProgramConstantFloatCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setFragmentProgramConstantFloatCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setFragmentProgramConstantIntCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setFragmentProgramConstantIntCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setFragmentProgramConstantBoolCount", VALUEFUNC(_wrap_RenderSystemCapabilities_setFragmentProgramConstantBoolCount), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setMaxPointSize", VALUEFUNC(_wrap_RenderSystemCapabilities_setMaxPointSize), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getMaxPointSize", VALUEFUNC(_wrap_RenderSystemCapabilities_getMaxPointSize), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setNonPOW2TexturesLimited", VALUEFUNC(_wrap_RenderSystemCapabilities_setNonPOW2TexturesLimited), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getNonPOW2TexturesLimited", VALUEFUNC(_wrap_RenderSystemCapabilities_getNonPOW2TexturesLimited), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setNumVertexTextureUnits", VALUEFUNC(_wrap_RenderSystemCapabilities_setNumVertexTextureUnits), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getNumVertexTextureUnits", VALUEFUNC(_wrap_RenderSystemCapabilities_getNumVertexTextureUnits), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setVertexTextureUnitsShared", VALUEFUNC(_wrap_RenderSystemCapabilities_setVertexTextureUnitsShared), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getVertexTextureUnitsShared", VALUEFUNC(_wrap_RenderSystemCapabilities_getVertexTextureUnitsShared), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setGeometryProgramNumOutputVertices", VALUEFUNC(_wrap_RenderSystemCapabilities_setGeometryProgramNumOutputVertices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getGeometryProgramNumOutputVertices", VALUEFUNC(_wrap_RenderSystemCapabilities_getGeometryProgramNumOutputVertices), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "getRenderSystemName", VALUEFUNC(_wrap_RenderSystemCapabilities_getRenderSystemName), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setRenderSystemName", VALUEFUNC(_wrap_RenderSystemCapabilities_setRenderSystemName), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "setCategoryRelevant", VALUEFUNC(_wrap_RenderSystemCapabilities_setCategoryRelevant), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "isCategoryRelevant", VALUEFUNC(_wrap_RenderSystemCapabilities_isCategoryRelevant), -1);
  rb_define_method(SwigClassRenderSystemCapabilities.klass, "log", VALUEFUNC(_wrap_RenderSystemCapabilities_log), -1);
  SwigClassRenderSystemCapabilities.mark = 0;
  SwigClassRenderSystemCapabilities.destroy = (void (*)(void *)) free_Ogre_RenderSystemCapabilities;
  SwigClassRenderSystemCapabilities.trackObjects = 0;
  
  SwigClassTextureManager.klass = rb_define_class_under(mOgre, "TextureManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TextureManager, (void *) &SwigClassTextureManager);
  rb_undef_alloc_func(SwigClassTextureManager.klass);
  rb_define_method(SwigClassTextureManager.klass, "createOrRetrieve", VALUEFUNC(_wrap_TextureManager_createOrRetrieve), -1);
  rb_define_method(SwigClassTextureManager.klass, "prepare", VALUEFUNC(_wrap_TextureManager_prepare), -1);
  rb_define_method(SwigClassTextureManager.klass, "load", VALUEFUNC(_wrap_TextureManager_load), -1);
  rb_define_method(SwigClassTextureManager.klass, "loadImage", VALUEFUNC(_wrap_TextureManager_loadImage), -1);
  rb_define_method(SwigClassTextureManager.klass, "loadRawData", VALUEFUNC(_wrap_TextureManager_loadRawData), -1);
  rb_define_method(SwigClassTextureManager.klass, "createManual", VALUEFUNC(_wrap_TextureManager_createManual), -1);
  rb_define_method(SwigClassTextureManager.klass, "setPreferredIntegerBitDepth", VALUEFUNC(_wrap_TextureManager_setPreferredIntegerBitDepth), -1);
  rb_define_method(SwigClassTextureManager.klass, "getPreferredIntegerBitDepth", VALUEFUNC(_wrap_TextureManager_getPreferredIntegerBitDepth), -1);
  rb_define_method(SwigClassTextureManager.klass, "setPreferredFloatBitDepth", VALUEFUNC(_wrap_TextureManager_setPreferredFloatBitDepth), -1);
  rb_define_method(SwigClassTextureManager.klass, "getPreferredFloatBitDepth", VALUEFUNC(_wrap_TextureManager_getPreferredFloatBitDepth), -1);
  rb_define_method(SwigClassTextureManager.klass, "setPreferredBitDepths", VALUEFUNC(_wrap_TextureManager_setPreferredBitDepths), -1);
  rb_define_method(SwigClassTextureManager.klass, "isFormatSupported", VALUEFUNC(_wrap_TextureManager_isFormatSupported), -1);
  rb_define_method(SwigClassTextureManager.klass, "isEquivalentFormatSupported", VALUEFUNC(_wrap_TextureManager_isEquivalentFormatSupported), -1);
  rb_define_method(SwigClassTextureManager.klass, "getNativeFormat", VALUEFUNC(_wrap_TextureManager_getNativeFormat), -1);
  rb_define_method(SwigClassTextureManager.klass, "isHardwareFilteringSupported", VALUEFUNC(_wrap_TextureManager_isHardwareFilteringSupported), -1);
  rb_define_method(SwigClassTextureManager.klass, "setDefaultNumMipmaps", VALUEFUNC(_wrap_TextureManager_setDefaultNumMipmaps), -1);
  rb_define_method(SwigClassTextureManager.klass, "getDefaultNumMipmaps", VALUEFUNC(_wrap_TextureManager_getDefaultNumMipmaps), -1);
  rb_define_singleton_method(SwigClassTextureManager.klass, "getSingleton", VALUEFUNC(_wrap_TextureManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassTextureManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_TextureManager_getSingletonPtr), -1);
  SwigClassTextureManager.mark = 0;
  SwigClassTextureManager.destroy = (void (*)(void *)) free_Ogre_TextureManager;
  SwigClassTextureManager.trackObjects = 0;
  
  SwigClassViewport.klass = rb_define_class_under(mOgre, "Viewport", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Viewport, (void *) &SwigClassViewport);
  rb_define_alloc_func(SwigClassViewport.klass, _wrap_Viewport_allocate);
  rb_define_method(SwigClassViewport.klass, "initialize", VALUEFUNC(_wrap_new_Viewport), -1);
  rb_define_method(SwigClassViewport.klass, "_updateDimensions", VALUEFUNC(_wrap_Viewport__updateDimensions), -1);
  rb_define_method(SwigClassViewport.klass, "update", VALUEFUNC(_wrap_Viewport_update), -1);
  rb_define_method(SwigClassViewport.klass, "clear", VALUEFUNC(_wrap_Viewport_clear), -1);
  rb_define_method(SwigClassViewport.klass, "getTarget", VALUEFUNC(_wrap_Viewport_getTarget), -1);
  rb_define_method(SwigClassViewport.klass, "getCamera", VALUEFUNC(_wrap_Viewport_getCamera), -1);
  rb_define_method(SwigClassViewport.klass, "setCamera", VALUEFUNC(_wrap_Viewport_setCamera), -1);
  rb_define_method(SwigClassViewport.klass, "getZOrder", VALUEFUNC(_wrap_Viewport_getZOrder), -1);
  rb_define_method(SwigClassViewport.klass, "getLeft", VALUEFUNC(_wrap_Viewport_getLeft), -1);
  rb_define_method(SwigClassViewport.klass, "getTop", VALUEFUNC(_wrap_Viewport_getTop), -1);
  rb_define_method(SwigClassViewport.klass, "getWidth", VALUEFUNC(_wrap_Viewport_getWidth), -1);
  rb_define_method(SwigClassViewport.klass, "getHeight", VALUEFUNC(_wrap_Viewport_getHeight), -1);
  rb_define_method(SwigClassViewport.klass, "getActualLeft", VALUEFUNC(_wrap_Viewport_getActualLeft), -1);
  rb_define_method(SwigClassViewport.klass, "getActualTop", VALUEFUNC(_wrap_Viewport_getActualTop), -1);
  rb_define_method(SwigClassViewport.klass, "getActualWidth", VALUEFUNC(_wrap_Viewport_getActualWidth), -1);
  rb_define_method(SwigClassViewport.klass, "getActualHeight", VALUEFUNC(_wrap_Viewport_getActualHeight), -1);
  rb_define_method(SwigClassViewport.klass, "setDimensions", VALUEFUNC(_wrap_Viewport_setDimensions), -1);
  rb_define_method(SwigClassViewport.klass, "setOrientationMode", VALUEFUNC(_wrap_Viewport_setOrientationMode), -1);
  rb_define_method(SwigClassViewport.klass, "getOrientationMode", VALUEFUNC(_wrap_Viewport_getOrientationMode), -1);
  rb_define_singleton_method(SwigClassViewport.klass, "setDefaultOrientationMode", VALUEFUNC(_wrap_Viewport_setDefaultOrientationMode), -1);
  rb_define_singleton_method(SwigClassViewport.klass, "getDefaultOrientationMode", VALUEFUNC(_wrap_Viewport_getDefaultOrientationMode), -1);
  rb_define_method(SwigClassViewport.klass, "setBackgroundColour", VALUEFUNC(_wrap_Viewport_setBackgroundColour), -1);
  rb_define_method(SwigClassViewport.klass, "getBackgroundColour", VALUEFUNC(_wrap_Viewport_getBackgroundColour), -1);
  rb_define_method(SwigClassViewport.klass, "setDepthClear", VALUEFUNC(_wrap_Viewport_setDepthClear), -1);
  rb_define_method(SwigClassViewport.klass, "getDepthClear", VALUEFUNC(_wrap_Viewport_getDepthClear), -1);
  rb_define_method(SwigClassViewport.klass, "setClearEveryFrame", VALUEFUNC(_wrap_Viewport_setClearEveryFrame), -1);
  rb_define_method(SwigClassViewport.klass, "getClearEveryFrame", VALUEFUNC(_wrap_Viewport_getClearEveryFrame), -1);
  rb_define_method(SwigClassViewport.klass, "getClearBuffers", VALUEFUNC(_wrap_Viewport_getClearBuffers), -1);
  rb_define_method(SwigClassViewport.klass, "setAutoUpdated", VALUEFUNC(_wrap_Viewport_setAutoUpdated), -1);
  rb_define_method(SwigClassViewport.klass, "isAutoUpdated", VALUEFUNC(_wrap_Viewport_isAutoUpdated), -1);
  rb_define_method(SwigClassViewport.klass, "setMaterialScheme", VALUEFUNC(_wrap_Viewport_setMaterialScheme), -1);
  rb_define_method(SwigClassViewport.klass, "getMaterialScheme", VALUEFUNC(_wrap_Viewport_getMaterialScheme), -1);
  rb_define_method(SwigClassViewport.klass, "getActualDimensions", VALUEFUNC(_wrap_Viewport_getActualDimensions), -1);
  rb_define_method(SwigClassViewport.klass, "_isUpdated", VALUEFUNC(_wrap_Viewport__isUpdated), -1);
  rb_define_method(SwigClassViewport.klass, "_clearUpdatedFlag", VALUEFUNC(_wrap_Viewport__clearUpdatedFlag), -1);
  rb_define_method(SwigClassViewport.klass, "_getNumRenderedFaces", VALUEFUNC(_wrap_Viewport__getNumRenderedFaces), -1);
  rb_define_method(SwigClassViewport.klass, "_getNumRenderedBatches", VALUEFUNC(_wrap_Viewport__getNumRenderedBatches), -1);
  rb_define_method(SwigClassViewport.klass, "setOverlaysEnabled", VALUEFUNC(_wrap_Viewport_setOverlaysEnabled), -1);
  rb_define_method(SwigClassViewport.klass, "getOverlaysEnabled", VALUEFUNC(_wrap_Viewport_getOverlaysEnabled), -1);
  rb_define_method(SwigClassViewport.klass, "setSkiesEnabled", VALUEFUNC(_wrap_Viewport_setSkiesEnabled), -1);
  rb_define_method(SwigClassViewport.klass, "getSkiesEnabled", VALUEFUNC(_wrap_Viewport_getSkiesEnabled), -1);
  rb_define_method(SwigClassViewport.klass, "setShadowsEnabled", VALUEFUNC(_wrap_Viewport_setShadowsEnabled), -1);
  rb_define_method(SwigClassViewport.klass, "getShadowsEnabled", VALUEFUNC(_wrap_Viewport_getShadowsEnabled), -1);
  rb_define_method(SwigClassViewport.klass, "setVisibilityMask", VALUEFUNC(_wrap_Viewport_setVisibilityMask), -1);
  rb_define_method(SwigClassViewport.klass, "getVisibilityMask", VALUEFUNC(_wrap_Viewport_getVisibilityMask), -1);
  rb_define_method(SwigClassViewport.klass, "setRenderQueueInvocationSequenceName", VALUEFUNC(_wrap_Viewport_setRenderQueueInvocationSequenceName), -1);
  rb_define_method(SwigClassViewport.klass, "getRenderQueueInvocationSequenceName", VALUEFUNC(_wrap_Viewport_getRenderQueueInvocationSequenceName), -1);
  rb_define_method(SwigClassViewport.klass, "_getRenderQueueInvocationSequence", VALUEFUNC(_wrap_Viewport__getRenderQueueInvocationSequence), -1);
  rb_define_method(SwigClassViewport.klass, "pointOrientedToScreen", VALUEFUNC(_wrap_Viewport_pointOrientedToScreen), -1);
  rb_define_method(SwigClassViewport.klass, "addListener", VALUEFUNC(_wrap_Viewport_addListener), -1);
  rb_define_method(SwigClassViewport.klass, "removeListener", VALUEFUNC(_wrap_Viewport_removeListener), -1);
  SwigClassViewport.mark = 0;
  SwigClassViewport.destroy = (void (*)(void *)) free_Ogre_Viewport;
  SwigClassViewport.trackObjects = 0;
  rb_define_const(mOgre, "OGRE_NUM_RENDERTARGET_GROUPS", SWIG_From_int(static_cast< int >(10)));
  rb_define_const(mOgre, "OGRE_DEFAULT_RT_GROUP", SWIG_From_int(static_cast< int >(4)));
  rb_define_const(mOgre, "OGRE_REND_TO_TEX_RT_GROUP", SWIG_From_int(static_cast< int >(2)));
  
  SwigClassRenderTarget.klass = rb_define_class_under(mOgre, "RenderTarget", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderTarget, (void *) &SwigClassRenderTarget);
  rb_undef_alloc_func(SwigClassRenderTarget.klass);
  rb_define_const(SwigClassRenderTarget.klass, "SF_NONE", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::SF_NONE)));
  rb_define_const(SwigClassRenderTarget.klass, "SF_FPS", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::SF_FPS)));
  rb_define_const(SwigClassRenderTarget.klass, "SF_AVG_FPS", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::SF_AVG_FPS)));
  rb_define_const(SwigClassRenderTarget.klass, "SF_BEST_FPS", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::SF_BEST_FPS)));
  rb_define_const(SwigClassRenderTarget.klass, "SF_WORST_FPS", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::SF_WORST_FPS)));
  rb_define_const(SwigClassRenderTarget.klass, "SF_TRIANGLE_COUNT", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::SF_TRIANGLE_COUNT)));
  rb_define_const(SwigClassRenderTarget.klass, "SF_ALL", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::SF_ALL)));
  rb_define_const(SwigClassRenderTarget.klass, "FB_FRONT", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::FB_FRONT)));
  rb_define_const(SwigClassRenderTarget.klass, "FB_BACK", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::FB_BACK)));
  rb_define_const(SwigClassRenderTarget.klass, "FB_AUTO", SWIG_From_int(static_cast< int >(Ogre::RenderTarget::FB_AUTO)));
  rb_define_method(SwigClassRenderTarget.klass, "getName", VALUEFUNC(_wrap_RenderTarget_getName), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getMetrics", VALUEFUNC(_wrap_RenderTarget_getMetrics), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getWidth", VALUEFUNC(_wrap_RenderTarget_getWidth), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getHeight", VALUEFUNC(_wrap_RenderTarget_getHeight), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getColourDepth", VALUEFUNC(_wrap_RenderTarget_getColourDepth), -1);
  rb_define_method(SwigClassRenderTarget.klass, "setDepthBufferPool", VALUEFUNC(_wrap_RenderTarget_setDepthBufferPool), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getDepthBufferPool", VALUEFUNC(_wrap_RenderTarget_getDepthBufferPool), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getDepthBuffer", VALUEFUNC(_wrap_RenderTarget_getDepthBuffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "attachDepthBuffer", VALUEFUNC(_wrap_RenderTarget_attachDepthBuffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "detachDepthBuffer", VALUEFUNC(_wrap_RenderTarget_detachDepthBuffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_detachDepthBuffer", VALUEFUNC(_wrap_RenderTarget__detachDepthBuffer), -1);
  rb_define_method(SwigClassRenderTarget.klass, "update", VALUEFUNC(_wrap_RenderTarget_update), -1);
  rb_define_method(SwigClassRenderTarget.klass, "swapBuffers", VALUEFUNC(_wrap_RenderTarget_swapBuffers), -1);
  rb_define_method(SwigClassRenderTarget.klass, "addViewport", VALUEFUNC(_wrap_RenderTarget_addViewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getNumViewports", VALUEFUNC(_wrap_RenderTarget_getNumViewports), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getViewport", VALUEFUNC(_wrap_RenderTarget_getViewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getViewportByZOrder", VALUEFUNC(_wrap_RenderTarget_getViewportByZOrder), -1);
  rb_define_method(SwigClassRenderTarget.klass, "hasViewportWithZOrder", VALUEFUNC(_wrap_RenderTarget_hasViewportWithZOrder), -1);
  rb_define_method(SwigClassRenderTarget.klass, "removeViewport", VALUEFUNC(_wrap_RenderTarget_removeViewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "removeAllViewports", VALUEFUNC(_wrap_RenderTarget_removeAllViewports), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getStatistics", VALUEFUNC(_wrap_RenderTarget_getStatistics), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getLastFPS", VALUEFUNC(_wrap_RenderTarget_getLastFPS), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getAverageFPS", VALUEFUNC(_wrap_RenderTarget_getAverageFPS), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getBestFPS", VALUEFUNC(_wrap_RenderTarget_getBestFPS), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getWorstFPS", VALUEFUNC(_wrap_RenderTarget_getWorstFPS), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getBestFrameTime", VALUEFUNC(_wrap_RenderTarget_getBestFrameTime), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getWorstFrameTime", VALUEFUNC(_wrap_RenderTarget_getWorstFrameTime), -1);
  rb_define_method(SwigClassRenderTarget.klass, "resetStatistics", VALUEFUNC(_wrap_RenderTarget_resetStatistics), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getCustomAttribute", VALUEFUNC(_wrap_RenderTarget_getCustomAttribute), -1);
  rb_define_method(SwigClassRenderTarget.klass, "addListener", VALUEFUNC(_wrap_RenderTarget_addListener), -1);
  rb_define_method(SwigClassRenderTarget.klass, "removeListener", VALUEFUNC(_wrap_RenderTarget_removeListener), -1);
  rb_define_method(SwigClassRenderTarget.klass, "removeAllListeners", VALUEFUNC(_wrap_RenderTarget_removeAllListeners), -1);
  rb_define_method(SwigClassRenderTarget.klass, "setPriority", VALUEFUNC(_wrap_RenderTarget_setPriority), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getPriority", VALUEFUNC(_wrap_RenderTarget_getPriority), -1);
  rb_define_method(SwigClassRenderTarget.klass, "isActive", VALUEFUNC(_wrap_RenderTarget_isActive), -1);
  rb_define_method(SwigClassRenderTarget.klass, "setActive", VALUEFUNC(_wrap_RenderTarget_setActive), -1);
  rb_define_method(SwigClassRenderTarget.klass, "setAutoUpdated", VALUEFUNC(_wrap_RenderTarget_setAutoUpdated), -1);
  rb_define_method(SwigClassRenderTarget.klass, "isAutoUpdated", VALUEFUNC(_wrap_RenderTarget_isAutoUpdated), -1);
  rb_define_method(SwigClassRenderTarget.klass, "copyContentsToMemory", VALUEFUNC(_wrap_RenderTarget_copyContentsToMemory), -1);
  rb_define_method(SwigClassRenderTarget.klass, "suggestPixelFormat", VALUEFUNC(_wrap_RenderTarget_suggestPixelFormat), -1);
  rb_define_method(SwigClassRenderTarget.klass, "writeContentsToFile", VALUEFUNC(_wrap_RenderTarget_writeContentsToFile), -1);
  rb_define_method(SwigClassRenderTarget.klass, "writeContentsToTimestampedFile", VALUEFUNC(_wrap_RenderTarget_writeContentsToTimestampedFile), -1);
  rb_define_method(SwigClassRenderTarget.klass, "requiresTextureFlipping", VALUEFUNC(_wrap_RenderTarget_requiresTextureFlipping), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getTriangleCount", VALUEFUNC(_wrap_RenderTarget_getTriangleCount), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getBatchCount", VALUEFUNC(_wrap_RenderTarget_getBatchCount), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_notifyCameraRemoved", VALUEFUNC(_wrap_RenderTarget__notifyCameraRemoved), -1);
  rb_define_method(SwigClassRenderTarget.klass, "isPrimary", VALUEFUNC(_wrap_RenderTarget_isPrimary), -1);
  rb_define_method(SwigClassRenderTarget.klass, "isHardwareGammaEnabled", VALUEFUNC(_wrap_RenderTarget_isHardwareGammaEnabled), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getFSAA", VALUEFUNC(_wrap_RenderTarget_getFSAA), -1);
  rb_define_method(SwigClassRenderTarget.klass, "getFSAAHint", VALUEFUNC(_wrap_RenderTarget_getFSAAHint), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_getImpl", VALUEFUNC(_wrap_RenderTarget__getImpl), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_beginUpdate", VALUEFUNC(_wrap_RenderTarget__beginUpdate), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_updateViewport", VALUEFUNC(_wrap_RenderTarget__updateViewport), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_updateAutoUpdatedViewports", VALUEFUNC(_wrap_RenderTarget__updateAutoUpdatedViewports), -1);
  rb_define_method(SwigClassRenderTarget.klass, "_endUpdate", VALUEFUNC(_wrap_RenderTarget__endUpdate), -1);
  SwigClassRenderTarget.mark = 0;
  SwigClassRenderTarget.destroy = (void (*)(void *)) free_Ogre_RenderTarget;
  SwigClassRenderTarget.trackObjects = 0;
  
  SwigClassRenderTexture.klass = rb_define_class_under(mOgre, "RenderTexture", ((swig_class *) SWIGTYPE_p_Ogre__RenderTarget->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderTexture, (void *) &SwigClassRenderTexture);
  rb_undef_alloc_func(SwigClassRenderTexture.klass);
  rb_define_method(SwigClassRenderTexture.klass, "copyContentsToMemory", VALUEFUNC(_wrap_RenderTexture_copyContentsToMemory), -1);
  rb_define_method(SwigClassRenderTexture.klass, "suggestPixelFormat", VALUEFUNC(_wrap_RenderTexture_suggestPixelFormat), -1);
  SwigClassRenderTexture.mark = 0;
  SwigClassRenderTexture.destroy = (void (*)(void *)) free_Ogre_RenderTexture;
  SwigClassRenderTexture.trackObjects = 0;
  
  SwigClassMultiRenderTarget.klass = rb_define_class_under(mOgre, "MultiRenderTarget", ((swig_class *) SWIGTYPE_p_Ogre__RenderTarget->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MultiRenderTarget, (void *) &SwigClassMultiRenderTarget);
  rb_undef_alloc_func(SwigClassMultiRenderTarget.klass);
  rb_define_method(SwigClassMultiRenderTarget.klass, "bindSurface", VALUEFUNC(_wrap_MultiRenderTarget_bindSurface), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "unbindSurface", VALUEFUNC(_wrap_MultiRenderTarget_unbindSurface), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "copyContentsToMemory", VALUEFUNC(_wrap_MultiRenderTarget_copyContentsToMemory), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "suggestPixelFormat", VALUEFUNC(_wrap_MultiRenderTarget_suggestPixelFormat), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "getBoundSurfaceList", VALUEFUNC(_wrap_MultiRenderTarget_getBoundSurfaceList), -1);
  rb_define_method(SwigClassMultiRenderTarget.klass, "getBoundSurface", VALUEFUNC(_wrap_MultiRenderTarget_getBoundSurface), -1);
  SwigClassMultiRenderTarget.mark = 0;
  SwigClassMultiRenderTarget.destroy = (void (*)(void *)) free_Ogre_MultiRenderTarget;
  SwigClassMultiRenderTarget.trackObjects = 0;
  
  SwigClassFrameEvent.klass = rb_define_class_under(mOgre, "FrameEvent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FrameEvent, (void *) &SwigClassFrameEvent);
  rb_define_alloc_func(SwigClassFrameEvent.klass, _wrap_FrameEvent_allocate);
  rb_define_method(SwigClassFrameEvent.klass, "initialize", VALUEFUNC(_wrap_new_FrameEvent), -1);
  rb_define_method(SwigClassFrameEvent.klass, "timeSinceLastEvent=", VALUEFUNC(_wrap_FrameEvent_timeSinceLastEvent_set), -1);
  rb_define_method(SwigClassFrameEvent.klass, "timeSinceLastEvent", VALUEFUNC(_wrap_FrameEvent_timeSinceLastEvent_get), -1);
  rb_define_method(SwigClassFrameEvent.klass, "timeSinceLastFrame=", VALUEFUNC(_wrap_FrameEvent_timeSinceLastFrame_set), -1);
  rb_define_method(SwigClassFrameEvent.klass, "timeSinceLastFrame", VALUEFUNC(_wrap_FrameEvent_timeSinceLastFrame_get), -1);
  SwigClassFrameEvent.mark = 0;
  SwigClassFrameEvent.destroy = (void (*)(void *)) free_Ogre_FrameEvent;
  SwigClassFrameEvent.trackObjects = 0;
  rb_define_module_function(mOgre, "disown_FrameListener", VALUEFUNC(_wrap_disown_FrameListener), -1);
  
  SwigClassFrameListener.klass = rb_define_class_under(mOgre, "FrameListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FrameListener, (void *) &SwigClassFrameListener);
  rb_define_alloc_func(SwigClassFrameListener.klass, _wrap_FrameListener_allocate);
  rb_define_method(SwigClassFrameListener.klass, "initialize", VALUEFUNC(_wrap_new_FrameListener), -1);
  rb_define_method(SwigClassFrameListener.klass, "frameStarted", VALUEFUNC(_wrap_FrameListener_frameStarted), -1);
  rb_define_method(SwigClassFrameListener.klass, "frameRenderingQueued", VALUEFUNC(_wrap_FrameListener_frameRenderingQueued), -1);
  rb_define_method(SwigClassFrameListener.klass, "frameEnded", VALUEFUNC(_wrap_FrameListener_frameEnded), -1);
  SwigClassFrameListener.mark = 0;
  SwigClassFrameListener.destroy = (void (*)(void *)) free_Ogre_FrameListener;
  SwigClassFrameListener.trackObjects = 0;
  
  SwigClassConfigOption.klass = rb_define_class_under(mOgre, "ConfigOption", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre___ConfigOption, (void *) &SwigClassConfigOption);
  rb_define_alloc_func(SwigClassConfigOption.klass, _wrap_ConfigOption_allocate);
  rb_define_method(SwigClassConfigOption.klass, "initialize", VALUEFUNC(_wrap_new_ConfigOption), -1);
  rb_define_method(SwigClassConfigOption.klass, "name=", VALUEFUNC(_wrap_ConfigOption_name_set), -1);
  rb_define_method(SwigClassConfigOption.klass, "name", VALUEFUNC(_wrap_ConfigOption_name_get), -1);
  rb_define_method(SwigClassConfigOption.klass, "currentValue=", VALUEFUNC(_wrap_ConfigOption_currentValue_set), -1);
  rb_define_method(SwigClassConfigOption.klass, "currentValue", VALUEFUNC(_wrap_ConfigOption_currentValue_get), -1);
  rb_define_method(SwigClassConfigOption.klass, "possibleValues=", VALUEFUNC(_wrap_ConfigOption_possibleValues_set), -1);
  rb_define_method(SwigClassConfigOption.klass, "possibleValues", VALUEFUNC(_wrap_ConfigOption_possibleValues_get), -1);
  rb_define_method(SwigClassConfigOption.klass, "immutable=", VALUEFUNC(_wrap_ConfigOption_immutable_set), -1);
  rb_define_method(SwigClassConfigOption.klass, "immutable", VALUEFUNC(_wrap_ConfigOption_immutable_get), -1);
  SwigClassConfigOption.mark = 0;
  SwigClassConfigOption.destroy = (void (*)(void *)) free_Ogre_ConfigOption;
  SwigClassConfigOption.trackObjects = 0;
  rb_define_const(mOgre, "TEXCALC_NONE", SWIG_From_int(static_cast< int >(Ogre::TEXCALC_NONE)));
  rb_define_const(mOgre, "TEXCALC_ENVIRONMENT_MAP", SWIG_From_int(static_cast< int >(Ogre::TEXCALC_ENVIRONMENT_MAP)));
  rb_define_const(mOgre, "TEXCALC_ENVIRONMENT_MAP_PLANAR", SWIG_From_int(static_cast< int >(Ogre::TEXCALC_ENVIRONMENT_MAP_PLANAR)));
  rb_define_const(mOgre, "TEXCALC_ENVIRONMENT_MAP_REFLECTION", SWIG_From_int(static_cast< int >(Ogre::TEXCALC_ENVIRONMENT_MAP_REFLECTION)));
  rb_define_const(mOgre, "TEXCALC_ENVIRONMENT_MAP_NORMAL", SWIG_From_int(static_cast< int >(Ogre::TEXCALC_ENVIRONMENT_MAP_NORMAL)));
  rb_define_const(mOgre, "TEXCALC_PROJECTIVE_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::TEXCALC_PROJECTIVE_TEXTURE)));
  rb_define_const(mOgre, "SOP_KEEP", SWIG_From_int(static_cast< int >(Ogre::SOP_KEEP)));
  rb_define_const(mOgre, "SOP_ZERO", SWIG_From_int(static_cast< int >(Ogre::SOP_ZERO)));
  rb_define_const(mOgre, "SOP_REPLACE", SWIG_From_int(static_cast< int >(Ogre::SOP_REPLACE)));
  rb_define_const(mOgre, "SOP_INCREMENT", SWIG_From_int(static_cast< int >(Ogre::SOP_INCREMENT)));
  rb_define_const(mOgre, "SOP_DECREMENT", SWIG_From_int(static_cast< int >(Ogre::SOP_DECREMENT)));
  rb_define_const(mOgre, "SOP_INCREMENT_WRAP", SWIG_From_int(static_cast< int >(Ogre::SOP_INCREMENT_WRAP)));
  rb_define_const(mOgre, "SOP_DECREMENT_WRAP", SWIG_From_int(static_cast< int >(Ogre::SOP_DECREMENT_WRAP)));
  rb_define_const(mOgre, "SOP_INVERT", SWIG_From_int(static_cast< int >(Ogre::SOP_INVERT)));
  
  SwigClassRenderSystem.klass = rb_define_class_under(mOgre, "RenderSystem", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderSystem, (void *) &SwigClassRenderSystem);
  rb_undef_alloc_func(SwigClassRenderSystem.klass);
  rb_define_method(SwigClassRenderSystem.klass, "getName", VALUEFUNC(_wrap_RenderSystem_getName), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getConfigOptions", VALUEFUNC(_wrap_RenderSystem_getConfigOptions), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setConfigOption", VALUEFUNC(_wrap_RenderSystem_setConfigOption), -1);
  rb_define_method(SwigClassRenderSystem.klass, "createHardwareOcclusionQuery", VALUEFUNC(_wrap_RenderSystem_createHardwareOcclusionQuery), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroyHardwareOcclusionQuery", VALUEFUNC(_wrap_RenderSystem_destroyHardwareOcclusionQuery), -1);
  rb_define_method(SwigClassRenderSystem.klass, "validateConfigOptions", VALUEFUNC(_wrap_RenderSystem_validateConfigOptions), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_initialise", VALUEFUNC(_wrap_RenderSystem__initialise), -1);
  rb_define_method(SwigClassRenderSystem.klass, "createRenderSystemCapabilities", VALUEFUNC(_wrap_RenderSystem_createRenderSystemCapabilities), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getMutableCapabilities", VALUEFUNC(_wrap_RenderSystem_getMutableCapabilities), -1);
  rb_define_method(SwigClassRenderSystem.klass, "useCustomRenderSystemCapabilities", VALUEFUNC(_wrap_RenderSystem_useCustomRenderSystemCapabilities), -1);
  rb_define_method(SwigClassRenderSystem.klass, "reinitialise", VALUEFUNC(_wrap_RenderSystem_reinitialise), -1);
  rb_define_method(SwigClassRenderSystem.klass, "shutdown", VALUEFUNC(_wrap_RenderSystem_shutdown), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setAmbientLight", VALUEFUNC(_wrap_RenderSystem_setAmbientLight), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setShadingType", VALUEFUNC(_wrap_RenderSystem_setShadingType), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setLightingEnabled", VALUEFUNC(_wrap_RenderSystem_setLightingEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setWBufferEnabled", VALUEFUNC(_wrap_RenderSystem_setWBufferEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getWBufferEnabled", VALUEFUNC(_wrap_RenderSystem_getWBufferEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_createRenderWindow", VALUEFUNC(_wrap_RenderSystem__createRenderWindow), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_createRenderWindows", VALUEFUNC(_wrap_RenderSystem__createRenderWindows), -1);
  rb_define_method(SwigClassRenderSystem.klass, "createMultiRenderTarget", VALUEFUNC(_wrap_RenderSystem_createMultiRenderTarget), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroyRenderWindow", VALUEFUNC(_wrap_RenderSystem_destroyRenderWindow), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroyRenderTexture", VALUEFUNC(_wrap_RenderSystem_destroyRenderTexture), -1);
  rb_define_method(SwigClassRenderSystem.klass, "destroyRenderTarget", VALUEFUNC(_wrap_RenderSystem_destroyRenderTarget), -1);
  rb_define_method(SwigClassRenderSystem.klass, "attachRenderTarget", VALUEFUNC(_wrap_RenderSystem_attachRenderTarget), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getRenderTarget", VALUEFUNC(_wrap_RenderSystem_getRenderTarget), -1);
  rb_define_method(SwigClassRenderSystem.klass, "detachRenderTarget", VALUEFUNC(_wrap_RenderSystem_detachRenderTarget), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getRenderTargetIterator", VALUEFUNC(_wrap_RenderSystem_getRenderTargetIterator), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getErrorDescription", VALUEFUNC(_wrap_RenderSystem_getErrorDescription), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setWaitForVerticalBlank", VALUEFUNC(_wrap_RenderSystem_setWaitForVerticalBlank), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getWaitForVerticalBlank", VALUEFUNC(_wrap_RenderSystem_getWaitForVerticalBlank), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getGlobalInstanceVertexBuffer", VALUEFUNC(_wrap_RenderSystem_getGlobalInstanceVertexBuffer), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setGlobalInstanceVertexBuffer", VALUEFUNC(_wrap_RenderSystem_setGlobalInstanceVertexBuffer), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getGlobalInstanceVertexBufferVertexDeclaration", VALUEFUNC(_wrap_RenderSystem_getGlobalInstanceVertexBufferVertexDeclaration), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setGlobalInstanceVertexBufferVertexDeclaration", VALUEFUNC(_wrap_RenderSystem_setGlobalInstanceVertexBufferVertexDeclaration), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getGlobalNumberOfInstances", VALUEFUNC(_wrap_RenderSystem_getGlobalNumberOfInstances), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setGlobalNumberOfInstances", VALUEFUNC(_wrap_RenderSystem_setGlobalNumberOfInstances), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setFixedPipelineEnabled", VALUEFUNC(_wrap_RenderSystem_setFixedPipelineEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getFixedPipelineEnabled", VALUEFUNC(_wrap_RenderSystem_getFixedPipelineEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setDepthBufferFor", VALUEFUNC(_wrap_RenderSystem_setDepthBufferFor), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_useLights", VALUEFUNC(_wrap_RenderSystem__useLights), -1);
  rb_define_method(SwigClassRenderSystem.klass, "areFixedFunctionLightsInViewSpace", VALUEFUNC(_wrap_RenderSystem_areFixedFunctionLightsInViewSpace), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setWorldMatrix", VALUEFUNC(_wrap_RenderSystem__setWorldMatrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setWorldMatrices", VALUEFUNC(_wrap_RenderSystem__setWorldMatrices), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setViewMatrix", VALUEFUNC(_wrap_RenderSystem__setViewMatrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setProjectionMatrix", VALUEFUNC(_wrap_RenderSystem__setProjectionMatrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureUnitSettings", VALUEFUNC(_wrap_RenderSystem__setTextureUnitSettings), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_disableTextureUnit", VALUEFUNC(_wrap_RenderSystem__disableTextureUnit), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_disableTextureUnitsFrom", VALUEFUNC(_wrap_RenderSystem__disableTextureUnitsFrom), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setSurfaceParams", VALUEFUNC(_wrap_RenderSystem__setSurfaceParams), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setPointSpritesEnabled", VALUEFUNC(_wrap_RenderSystem__setPointSpritesEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setPointParameters", VALUEFUNC(_wrap_RenderSystem__setPointParameters), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTexture", VALUEFUNC(_wrap_RenderSystem__setTexture), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setVertexTexture", VALUEFUNC(_wrap_RenderSystem__setVertexTexture), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureCoordSet", VALUEFUNC(_wrap_RenderSystem__setTextureCoordSet), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureCoordCalculation", VALUEFUNC(_wrap_RenderSystem__setTextureCoordCalculation), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureBlendMode", VALUEFUNC(_wrap_RenderSystem__setTextureBlendMode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureUnitFiltering", VALUEFUNC(_wrap_RenderSystem__setTextureUnitFiltering), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureLayerAnisotropy", VALUEFUNC(_wrap_RenderSystem__setTextureLayerAnisotropy), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureAddressingMode", VALUEFUNC(_wrap_RenderSystem__setTextureAddressingMode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureBorderColour", VALUEFUNC(_wrap_RenderSystem__setTextureBorderColour), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureMipmapBias", VALUEFUNC(_wrap_RenderSystem__setTextureMipmapBias), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureMatrix", VALUEFUNC(_wrap_RenderSystem__setTextureMatrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setSceneBlending", VALUEFUNC(_wrap_RenderSystem__setSceneBlending), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setSeparateSceneBlending", VALUEFUNC(_wrap_RenderSystem__setSeparateSceneBlending), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setAlphaRejectSettings", VALUEFUNC(_wrap_RenderSystem__setAlphaRejectSettings), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setTextureProjectionRelativeTo", VALUEFUNC(_wrap_RenderSystem__setTextureProjectionRelativeTo), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_createDepthBufferFor", VALUEFUNC(_wrap_RenderSystem__createDepthBufferFor), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_cleanupDepthBuffers", VALUEFUNC(_wrap_RenderSystem__cleanupDepthBuffers), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_beginFrame", VALUEFUNC(_wrap_RenderSystem__beginFrame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_pauseFrame", VALUEFUNC(_wrap_RenderSystem__pauseFrame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_resumeFrame", VALUEFUNC(_wrap_RenderSystem__resumeFrame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_endFrame", VALUEFUNC(_wrap_RenderSystem__endFrame), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setViewport", VALUEFUNC(_wrap_RenderSystem__setViewport), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_getViewport", VALUEFUNC(_wrap_RenderSystem__getViewport), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setCullingMode", VALUEFUNC(_wrap_RenderSystem__setCullingMode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_getCullingMode", VALUEFUNC(_wrap_RenderSystem__getCullingMode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setDepthBufferParams", VALUEFUNC(_wrap_RenderSystem__setDepthBufferParams), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setDepthBufferCheckEnabled", VALUEFUNC(_wrap_RenderSystem__setDepthBufferCheckEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setDepthBufferWriteEnabled", VALUEFUNC(_wrap_RenderSystem__setDepthBufferWriteEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setDepthBufferFunction", VALUEFUNC(_wrap_RenderSystem__setDepthBufferFunction), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setColourBufferWriteEnabled", VALUEFUNC(_wrap_RenderSystem__setColourBufferWriteEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setDepthBias", VALUEFUNC(_wrap_RenderSystem__setDepthBias), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setFog", VALUEFUNC(_wrap_RenderSystem__setFog), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_beginGeometryCount", VALUEFUNC(_wrap_RenderSystem__beginGeometryCount), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_getFaceCount", VALUEFUNC(_wrap_RenderSystem__getFaceCount), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_getBatchCount", VALUEFUNC(_wrap_RenderSystem__getBatchCount), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_getVertexCount", VALUEFUNC(_wrap_RenderSystem__getVertexCount), -1);
  rb_define_method(SwigClassRenderSystem.klass, "convertColourValue", VALUEFUNC(_wrap_RenderSystem_convertColourValue), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getColourVertexElementType", VALUEFUNC(_wrap_RenderSystem_getColourVertexElementType), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_convertProjectionMatrix", VALUEFUNC(_wrap_RenderSystem__convertProjectionMatrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_makeProjectionMatrix", VALUEFUNC(_wrap_RenderSystem__makeProjectionMatrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_makeOrthoMatrix", VALUEFUNC(_wrap_RenderSystem__makeOrthoMatrix), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_applyObliqueDepthProjection", VALUEFUNC(_wrap_RenderSystem__applyObliqueDepthProjection), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setPolygonMode", VALUEFUNC(_wrap_RenderSystem__setPolygonMode), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setStencilCheckEnabled", VALUEFUNC(_wrap_RenderSystem_setStencilCheckEnabled), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setStencilBufferParams", VALUEFUNC(_wrap_RenderSystem_setStencilBufferParams), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setVertexDeclaration", VALUEFUNC(_wrap_RenderSystem_setVertexDeclaration), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setVertexBufferBinding", VALUEFUNC(_wrap_RenderSystem_setVertexBufferBinding), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setNormaliseNormals", VALUEFUNC(_wrap_RenderSystem_setNormaliseNormals), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_render", VALUEFUNC(_wrap_RenderSystem__render), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getCapabilities", VALUEFUNC(_wrap_RenderSystem_getCapabilities), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getDriverVersion", VALUEFUNC(_wrap_RenderSystem_getDriverVersion), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_getDefaultViewportMaterialScheme", VALUEFUNC(_wrap_RenderSystem__getDefaultViewportMaterialScheme), -1);
  rb_define_method(SwigClassRenderSystem.klass, "bindGpuProgram", VALUEFUNC(_wrap_RenderSystem_bindGpuProgram), -1);
  rb_define_method(SwigClassRenderSystem.klass, "bindGpuProgramParameters", VALUEFUNC(_wrap_RenderSystem_bindGpuProgramParameters), -1);
  rb_define_method(SwigClassRenderSystem.klass, "bindGpuProgramPassIterationParameters", VALUEFUNC(_wrap_RenderSystem_bindGpuProgramPassIterationParameters), -1);
  rb_define_method(SwigClassRenderSystem.klass, "unbindGpuProgram", VALUEFUNC(_wrap_RenderSystem_unbindGpuProgram), -1);
  rb_define_method(SwigClassRenderSystem.klass, "isGpuProgramBound", VALUEFUNC(_wrap_RenderSystem_isGpuProgramBound), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setClipPlanes", VALUEFUNC(_wrap_RenderSystem_setClipPlanes), -1);
  rb_define_method(SwigClassRenderSystem.klass, "addClipPlane", VALUEFUNC(_wrap_RenderSystem_addClipPlane), -1);
  rb_define_method(SwigClassRenderSystem.klass, "resetClipPlanes", VALUEFUNC(_wrap_RenderSystem_resetClipPlanes), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_initRenderTargets", VALUEFUNC(_wrap_RenderSystem__initRenderTargets), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_notifyCameraRemoved", VALUEFUNC(_wrap_RenderSystem__notifyCameraRemoved), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_updateAllRenderTargets", VALUEFUNC(_wrap_RenderSystem__updateAllRenderTargets), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_swapAllRenderTargetBuffers", VALUEFUNC(_wrap_RenderSystem__swapAllRenderTargetBuffers), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setInvertVertexWinding", VALUEFUNC(_wrap_RenderSystem_setInvertVertexWinding), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getInvertVertexWinding", VALUEFUNC(_wrap_RenderSystem_getInvertVertexWinding), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setScissorTest", VALUEFUNC(_wrap_RenderSystem_setScissorTest), -1);
  rb_define_method(SwigClassRenderSystem.klass, "clearFrameBuffer", VALUEFUNC(_wrap_RenderSystem_clearFrameBuffer), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getHorizontalTexelOffset", VALUEFUNC(_wrap_RenderSystem_getHorizontalTexelOffset), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getVerticalTexelOffset", VALUEFUNC(_wrap_RenderSystem_getVerticalTexelOffset), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getMinimumDepthInputValue", VALUEFUNC(_wrap_RenderSystem_getMinimumDepthInputValue), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getMaximumDepthInputValue", VALUEFUNC(_wrap_RenderSystem_getMaximumDepthInputValue), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setCurrentPassIterationCount", VALUEFUNC(_wrap_RenderSystem_setCurrentPassIterationCount), -1);
  rb_define_method(SwigClassRenderSystem.klass, "setDeriveDepthBias", VALUEFUNC(_wrap_RenderSystem_setDeriveDepthBias), -1);
  rb_define_method(SwigClassRenderSystem.klass, "_setRenderTarget", VALUEFUNC(_wrap_RenderSystem__setRenderTarget), -1);
  rb_define_method(SwigClassRenderSystem.klass, "addListener", VALUEFUNC(_wrap_RenderSystem_addListener), -1);
  rb_define_method(SwigClassRenderSystem.klass, "removeListener", VALUEFUNC(_wrap_RenderSystem_removeListener), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getRenderSystemEvents", VALUEFUNC(_wrap_RenderSystem_getRenderSystemEvents), -1);
  rb_define_method(SwigClassRenderSystem.klass, "preExtraThreadsStarted", VALUEFUNC(_wrap_RenderSystem_preExtraThreadsStarted), -1);
  rb_define_method(SwigClassRenderSystem.klass, "postExtraThreadsStarted", VALUEFUNC(_wrap_RenderSystem_postExtraThreadsStarted), -1);
  rb_define_method(SwigClassRenderSystem.klass, "registerThread", VALUEFUNC(_wrap_RenderSystem_registerThread), -1);
  rb_define_method(SwigClassRenderSystem.klass, "unregisterThread", VALUEFUNC(_wrap_RenderSystem_unregisterThread), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getDisplayMonitorCount", VALUEFUNC(_wrap_RenderSystem_getDisplayMonitorCount), -1);
  rb_define_method(SwigClassRenderSystem.klass, "getConfigOptionHash", VALUEFUNC(_wrap_RenderSystem_getConfigOptionHash), -1);
  SwigClassRenderSystem.mark = 0;
  SwigClassRenderSystem.destroy = (void (*)(void *)) free_Ogre_RenderSystem;
  SwigClassRenderSystem.trackObjects = 0;
  
  SwigClassCompositionPass.klass = rb_define_class_under(mOgre, "CompositionPass", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositionPass, (void *) &SwigClassCompositionPass);
  rb_define_alloc_func(SwigClassCompositionPass.klass, _wrap_CompositionPass_allocate);
  rb_define_method(SwigClassCompositionPass.klass, "initialize", VALUEFUNC(_wrap_new_CompositionPass), -1);
  rb_define_const(SwigClassCompositionPass.klass, "PT_CLEAR", SWIG_From_int(static_cast< int >(Ogre::CompositionPass::PT_CLEAR)));
  rb_define_const(SwigClassCompositionPass.klass, "PT_STENCIL", SWIG_From_int(static_cast< int >(Ogre::CompositionPass::PT_STENCIL)));
  rb_define_const(SwigClassCompositionPass.klass, "PT_RENDERSCENE", SWIG_From_int(static_cast< int >(Ogre::CompositionPass::PT_RENDERSCENE)));
  rb_define_const(SwigClassCompositionPass.klass, "PT_RENDERQUAD", SWIG_From_int(static_cast< int >(Ogre::CompositionPass::PT_RENDERQUAD)));
  rb_define_const(SwigClassCompositionPass.klass, "PT_RENDERCUSTOM", SWIG_From_int(static_cast< int >(Ogre::CompositionPass::PT_RENDERCUSTOM)));
  rb_define_method(SwigClassCompositionPass.klass, "setType", VALUEFUNC(_wrap_CompositionPass_setType), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getType", VALUEFUNC(_wrap_CompositionPass_getType), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setIdentifier", VALUEFUNC(_wrap_CompositionPass_setIdentifier), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getIdentifier", VALUEFUNC(_wrap_CompositionPass_getIdentifier), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setMaterial", VALUEFUNC(_wrap_CompositionPass_setMaterial), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setMaterialName", VALUEFUNC(_wrap_CompositionPass_setMaterialName), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getMaterial", VALUEFUNC(_wrap_CompositionPass_getMaterial), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setFirstRenderQueue", VALUEFUNC(_wrap_CompositionPass_setFirstRenderQueue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getFirstRenderQueue", VALUEFUNC(_wrap_CompositionPass_getFirstRenderQueue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setLastRenderQueue", VALUEFUNC(_wrap_CompositionPass_setLastRenderQueue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getLastRenderQueue", VALUEFUNC(_wrap_CompositionPass_getLastRenderQueue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setMaterialScheme", VALUEFUNC(_wrap_CompositionPass_setMaterialScheme), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getMaterialScheme", VALUEFUNC(_wrap_CompositionPass_getMaterialScheme), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setClearBuffers", VALUEFUNC(_wrap_CompositionPass_setClearBuffers), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getClearBuffers", VALUEFUNC(_wrap_CompositionPass_getClearBuffers), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setClearColour", VALUEFUNC(_wrap_CompositionPass_setClearColour), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getClearColour", VALUEFUNC(_wrap_CompositionPass_getClearColour), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setClearDepth", VALUEFUNC(_wrap_CompositionPass_setClearDepth), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getClearDepth", VALUEFUNC(_wrap_CompositionPass_getClearDepth), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setClearStencil", VALUEFUNC(_wrap_CompositionPass_setClearStencil), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getClearStencil", VALUEFUNC(_wrap_CompositionPass_getClearStencil), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilCheck", VALUEFUNC(_wrap_CompositionPass_setStencilCheck), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilCheck", VALUEFUNC(_wrap_CompositionPass_getStencilCheck), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilFunc", VALUEFUNC(_wrap_CompositionPass_setStencilFunc), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilFunc", VALUEFUNC(_wrap_CompositionPass_getStencilFunc), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilRefValue", VALUEFUNC(_wrap_CompositionPass_setStencilRefValue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilRefValue", VALUEFUNC(_wrap_CompositionPass_getStencilRefValue), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilMask", VALUEFUNC(_wrap_CompositionPass_setStencilMask), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilMask", VALUEFUNC(_wrap_CompositionPass_getStencilMask), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilFailOp", VALUEFUNC(_wrap_CompositionPass_setStencilFailOp), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilFailOp", VALUEFUNC(_wrap_CompositionPass_getStencilFailOp), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilDepthFailOp", VALUEFUNC(_wrap_CompositionPass_setStencilDepthFailOp), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilDepthFailOp", VALUEFUNC(_wrap_CompositionPass_getStencilDepthFailOp), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilPassOp", VALUEFUNC(_wrap_CompositionPass_setStencilPassOp), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilPassOp", VALUEFUNC(_wrap_CompositionPass_getStencilPassOp), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setStencilTwoSidedOperation", VALUEFUNC(_wrap_CompositionPass_setStencilTwoSidedOperation), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getStencilTwoSidedOperation", VALUEFUNC(_wrap_CompositionPass_getStencilTwoSidedOperation), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setInput", VALUEFUNC(_wrap_CompositionPass_setInput), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getInput", VALUEFUNC(_wrap_CompositionPass_getInput), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getNumInputs", VALUEFUNC(_wrap_CompositionPass_getNumInputs), -1);
  rb_define_method(SwigClassCompositionPass.klass, "clearAllInputs", VALUEFUNC(_wrap_CompositionPass_clearAllInputs), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getParent", VALUEFUNC(_wrap_CompositionPass_getParent), -1);
  rb_define_method(SwigClassCompositionPass.klass, "_isSupported", VALUEFUNC(_wrap_CompositionPass__isSupported), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setQuadCorners", VALUEFUNC(_wrap_CompositionPass_setQuadCorners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getQuadCorners", VALUEFUNC(_wrap_CompositionPass_getQuadCorners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setQuadFarCorners", VALUEFUNC(_wrap_CompositionPass_setQuadFarCorners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getQuadFarCorners", VALUEFUNC(_wrap_CompositionPass_getQuadFarCorners), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getQuadFarCornersViewSpace", VALUEFUNC(_wrap_CompositionPass_getQuadFarCornersViewSpace), -1);
  rb_define_method(SwigClassCompositionPass.klass, "setCustomType", VALUEFUNC(_wrap_CompositionPass_setCustomType), -1);
  rb_define_method(SwigClassCompositionPass.klass, "getCustomType", VALUEFUNC(_wrap_CompositionPass_getCustomType), -1);
  SwigClassCompositionPass.mark = 0;
  SwigClassCompositionPass.destroy = (void (*)(void *)) free_Ogre_CompositionPass;
  SwigClassCompositionPass.trackObjects = 0;
  
  SwigClassCompositionTargetPass.klass = rb_define_class_under(mOgre, "CompositionTargetPass", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositionTargetPass, (void *) &SwigClassCompositionTargetPass);
  rb_define_alloc_func(SwigClassCompositionTargetPass.klass, _wrap_CompositionTargetPass_allocate);
  rb_define_method(SwigClassCompositionTargetPass.klass, "initialize", VALUEFUNC(_wrap_new_CompositionTargetPass), -1);
  rb_define_const(SwigClassCompositionTargetPass.klass, "IM_NONE", SWIG_From_int(static_cast< int >(Ogre::CompositionTargetPass::IM_NONE)));
  rb_define_const(SwigClassCompositionTargetPass.klass, "IM_PREVIOUS", SWIG_From_int(static_cast< int >(Ogre::CompositionTargetPass::IM_PREVIOUS)));
  rb_define_method(SwigClassCompositionTargetPass.klass, "setInputMode", VALUEFUNC(_wrap_CompositionTargetPass_setInputMode), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getInputMode", VALUEFUNC(_wrap_CompositionTargetPass_getInputMode), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "setOutputName", VALUEFUNC(_wrap_CompositionTargetPass_setOutputName), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getOutputName", VALUEFUNC(_wrap_CompositionTargetPass_getOutputName), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "setOnlyInitial", VALUEFUNC(_wrap_CompositionTargetPass_setOnlyInitial), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getOnlyInitial", VALUEFUNC(_wrap_CompositionTargetPass_getOnlyInitial), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "setVisibilityMask", VALUEFUNC(_wrap_CompositionTargetPass_setVisibilityMask), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getVisibilityMask", VALUEFUNC(_wrap_CompositionTargetPass_getVisibilityMask), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "setMaterialScheme", VALUEFUNC(_wrap_CompositionTargetPass_setMaterialScheme), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getMaterialScheme", VALUEFUNC(_wrap_CompositionTargetPass_getMaterialScheme), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "setShadowsEnabled", VALUEFUNC(_wrap_CompositionTargetPass_setShadowsEnabled), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getShadowsEnabled", VALUEFUNC(_wrap_CompositionTargetPass_getShadowsEnabled), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "setLodBias", VALUEFUNC(_wrap_CompositionTargetPass_setLodBias), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getLodBias", VALUEFUNC(_wrap_CompositionTargetPass_getLodBias), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "createPass", VALUEFUNC(_wrap_CompositionTargetPass_createPass), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "removePass", VALUEFUNC(_wrap_CompositionTargetPass_removePass), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getPass", VALUEFUNC(_wrap_CompositionTargetPass_getPass), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getNumPasses", VALUEFUNC(_wrap_CompositionTargetPass_getNumPasses), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "removeAllPasses", VALUEFUNC(_wrap_CompositionTargetPass_removeAllPasses), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getPassIterator", VALUEFUNC(_wrap_CompositionTargetPass_getPassIterator), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "getParent", VALUEFUNC(_wrap_CompositionTargetPass_getParent), -1);
  rb_define_method(SwigClassCompositionTargetPass.klass, "_isSupported", VALUEFUNC(_wrap_CompositionTargetPass__isSupported), -1);
  SwigClassCompositionTargetPass.mark = 0;
  SwigClassCompositionTargetPass.destroy = (void (*)(void *)) free_Ogre_CompositionTargetPass;
  SwigClassCompositionTargetPass.trackObjects = 0;
  
  SwigClassCompositionTechnique.klass = rb_define_class_under(mOgre, "CompositionTechnique", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositionTechnique, (void *) &SwigClassCompositionTechnique);
  rb_define_alloc_func(SwigClassCompositionTechnique.klass, _wrap_CompositionTechnique_allocate);
  rb_define_method(SwigClassCompositionTechnique.klass, "initialize", VALUEFUNC(_wrap_new_CompositionTechnique), -1);
  rb_define_const(SwigClassCompositionTechnique.klass, "TS_LOCAL", SWIG_From_int(static_cast< int >(Ogre::CompositionTechnique::TS_LOCAL)));
  rb_define_const(SwigClassCompositionTechnique.klass, "TS_CHAIN", SWIG_From_int(static_cast< int >(Ogre::CompositionTechnique::TS_CHAIN)));
  rb_define_const(SwigClassCompositionTechnique.klass, "TS_GLOBAL", SWIG_From_int(static_cast< int >(Ogre::CompositionTechnique::TS_GLOBAL)));
  rb_define_method(SwigClassCompositionTechnique.klass, "createTextureDefinition", VALUEFUNC(_wrap_CompositionTechnique_createTextureDefinition), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "removeTextureDefinition", VALUEFUNC(_wrap_CompositionTechnique_removeTextureDefinition), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getTextureDefinition", VALUEFUNC(_wrap_CompositionTechnique_getTextureDefinition), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getNumTextureDefinitions", VALUEFUNC(_wrap_CompositionTechnique_getNumTextureDefinitions), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "removeAllTextureDefinitions", VALUEFUNC(_wrap_CompositionTechnique_removeAllTextureDefinitions), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getTextureDefinitionIterator", VALUEFUNC(_wrap_CompositionTechnique_getTextureDefinitionIterator), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "createTargetPass", VALUEFUNC(_wrap_CompositionTechnique_createTargetPass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "removeTargetPass", VALUEFUNC(_wrap_CompositionTechnique_removeTargetPass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getTargetPass", VALUEFUNC(_wrap_CompositionTechnique_getTargetPass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getNumTargetPasses", VALUEFUNC(_wrap_CompositionTechnique_getNumTargetPasses), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "removeAllTargetPasses", VALUEFUNC(_wrap_CompositionTechnique_removeAllTargetPasses), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getTargetPassIterator", VALUEFUNC(_wrap_CompositionTechnique_getTargetPassIterator), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getOutputTargetPass", VALUEFUNC(_wrap_CompositionTechnique_getOutputTargetPass), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "isSupported", VALUEFUNC(_wrap_CompositionTechnique_isSupported), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "setSchemeName", VALUEFUNC(_wrap_CompositionTechnique_setSchemeName), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getSchemeName", VALUEFUNC(_wrap_CompositionTechnique_getSchemeName), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "setCompositorLogicName", VALUEFUNC(_wrap_CompositionTechnique_setCompositorLogicName), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getCompositorLogicName", VALUEFUNC(_wrap_CompositionTechnique_getCompositorLogicName), -1);
  rb_define_method(SwigClassCompositionTechnique.klass, "getParent", VALUEFUNC(_wrap_CompositionTechnique_getParent), -1);
  SwigClassCompositionTechnique.mark = 0;
  SwigClassCompositionTechnique.destroy = (void (*)(void *)) free_Ogre_CompositionTechnique;
  SwigClassCompositionTechnique.trackObjects = 0;
  
  SwigClassCompositor.klass = rb_define_class_under(mOgre, "Compositor", ((swig_class *) SWIGTYPE_p_Ogre__Resource->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Compositor, (void *) &SwigClassCompositor);
  rb_define_alloc_func(SwigClassCompositor.klass, _wrap_Compositor_allocate);
  rb_define_method(SwigClassCompositor.klass, "initialize", VALUEFUNC(_wrap_new_Compositor), -1);
  rb_define_method(SwigClassCompositor.klass, "createTechnique", VALUEFUNC(_wrap_Compositor_createTechnique), -1);
  rb_define_method(SwigClassCompositor.klass, "removeTechnique", VALUEFUNC(_wrap_Compositor_removeTechnique), -1);
  rb_define_method(SwigClassCompositor.klass, "getTechnique", VALUEFUNC(_wrap_Compositor_getTechnique), -1);
  rb_define_method(SwigClassCompositor.klass, "getNumTechniques", VALUEFUNC(_wrap_Compositor_getNumTechniques), -1);
  rb_define_method(SwigClassCompositor.klass, "removeAllTechniques", VALUEFUNC(_wrap_Compositor_removeAllTechniques), -1);
  rb_define_method(SwigClassCompositor.klass, "getTechniqueIterator", VALUEFUNC(_wrap_Compositor_getTechniqueIterator), -1);
  rb_define_method(SwigClassCompositor.klass, "getNumSupportedTechniques", VALUEFUNC(_wrap_Compositor_getNumSupportedTechniques), -1);
  rb_define_method(SwigClassCompositor.klass, "getSupportedTechniqueIterator", VALUEFUNC(_wrap_Compositor_getSupportedTechniqueIterator), -1);
  rb_define_method(SwigClassCompositor.klass, "getSupportedTechnique", VALUEFUNC(_wrap_Compositor_getSupportedTechnique), -1);
  rb_define_method(SwigClassCompositor.klass, "getTextureInstanceName", VALUEFUNC(_wrap_Compositor_getTextureInstanceName), -1);
  rb_define_method(SwigClassCompositor.klass, "getTextureInstance", VALUEFUNC(_wrap_Compositor_getTextureInstance), -1);
  rb_define_method(SwigClassCompositor.klass, "getRenderTarget", VALUEFUNC(_wrap_Compositor_getRenderTarget), -1);
  SwigClassCompositor.mark = 0;
  SwigClassCompositor.destroy = (void (*)(void *)) free_Ogre_Compositor;
  SwigClassCompositor.trackObjects = 0;
  
  SwigClassCompositorPtr.klass = rb_define_class_under(mOgre, "CompositorPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositorPtr, (void *) &SwigClassCompositorPtr);
  rb_define_alloc_func(SwigClassCompositorPtr.klass, _wrap_CompositorPtr_allocate);
  rb_define_method(SwigClassCompositorPtr.klass, "initialize", VALUEFUNC(_wrap_new_CompositorPtr), -1);
  SwigClassCompositorPtr.mark = 0;
  SwigClassCompositorPtr.destroy = (void (*)(void *)) free_Ogre_CompositorPtr;
  SwigClassCompositorPtr.trackObjects = 0;
  
  SwigClassRenderTargetEvent.klass = rb_define_class_under(mOgre, "RenderTargetEvent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderTargetEvent, (void *) &SwigClassRenderTargetEvent);
  rb_define_alloc_func(SwigClassRenderTargetEvent.klass, _wrap_RenderTargetEvent_allocate);
  rb_define_method(SwigClassRenderTargetEvent.klass, "initialize", VALUEFUNC(_wrap_new_RenderTargetEvent), -1);
  rb_define_method(SwigClassRenderTargetEvent.klass, "source=", VALUEFUNC(_wrap_RenderTargetEvent_source_set), -1);
  rb_define_method(SwigClassRenderTargetEvent.klass, "source", VALUEFUNC(_wrap_RenderTargetEvent_source_get), -1);
  SwigClassRenderTargetEvent.mark = 0;
  SwigClassRenderTargetEvent.destroy = (void (*)(void *)) free_Ogre_RenderTargetEvent;
  SwigClassRenderTargetEvent.trackObjects = 0;
  
  SwigClassRenderTargetViewportEvent.klass = rb_define_class_under(mOgre, "RenderTargetViewportEvent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderTargetViewportEvent, (void *) &SwigClassRenderTargetViewportEvent);
  rb_define_alloc_func(SwigClassRenderTargetViewportEvent.klass, _wrap_RenderTargetViewportEvent_allocate);
  rb_define_method(SwigClassRenderTargetViewportEvent.klass, "initialize", VALUEFUNC(_wrap_new_RenderTargetViewportEvent), -1);
  rb_define_method(SwigClassRenderTargetViewportEvent.klass, "source=", VALUEFUNC(_wrap_RenderTargetViewportEvent_source_set), -1);
  rb_define_method(SwigClassRenderTargetViewportEvent.klass, "source", VALUEFUNC(_wrap_RenderTargetViewportEvent_source_get), -1);
  SwigClassRenderTargetViewportEvent.mark = 0;
  SwigClassRenderTargetViewportEvent.destroy = (void (*)(void *)) free_Ogre_RenderTargetViewportEvent;
  SwigClassRenderTargetViewportEvent.trackObjects = 0;
  rb_define_module_function(mOgre, "disown_RenderTargetListener", VALUEFUNC(_wrap_disown_RenderTargetListener), -1);
  
  SwigClassRenderTargetListener.klass = rb_define_class_under(mOgre, "RenderTargetListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderTargetListener, (void *) &SwigClassRenderTargetListener);
  rb_define_alloc_func(SwigClassRenderTargetListener.klass, _wrap_RenderTargetListener_allocate);
  rb_define_method(SwigClassRenderTargetListener.klass, "initialize", VALUEFUNC(_wrap_new_RenderTargetListener), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "preRenderTargetUpdate", VALUEFUNC(_wrap_RenderTargetListener_preRenderTargetUpdate), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "postRenderTargetUpdate", VALUEFUNC(_wrap_RenderTargetListener_postRenderTargetUpdate), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "preViewportUpdate", VALUEFUNC(_wrap_RenderTargetListener_preViewportUpdate), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "postViewportUpdate", VALUEFUNC(_wrap_RenderTargetListener_postViewportUpdate), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "viewportAdded", VALUEFUNC(_wrap_RenderTargetListener_viewportAdded), -1);
  rb_define_method(SwigClassRenderTargetListener.klass, "viewportRemoved", VALUEFUNC(_wrap_RenderTargetListener_viewportRemoved), -1);
  SwigClassRenderTargetListener.mark = 0;
  SwigClassRenderTargetListener.destroy = (void (*)(void *)) free_Ogre_RenderTargetListener;
  SwigClassRenderTargetListener.trackObjects = 0;
  rb_define_module_function(mOgre, "disown_RenderQueueListener", VALUEFUNC(_wrap_disown_RenderQueueListener), -1);
  
  SwigClassRenderQueueListener.klass = rb_define_class_under(mOgre, "RenderQueueListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderQueueListener, (void *) &SwigClassRenderQueueListener);
  rb_define_alloc_func(SwigClassRenderQueueListener.klass, _wrap_RenderQueueListener_allocate);
  rb_define_method(SwigClassRenderQueueListener.klass, "initialize", VALUEFUNC(_wrap_new_RenderQueueListener), -1);
  rb_define_method(SwigClassRenderQueueListener.klass, "preRenderQueues", VALUEFUNC(_wrap_RenderQueueListener_preRenderQueues), -1);
  rb_define_method(SwigClassRenderQueueListener.klass, "postRenderQueues", VALUEFUNC(_wrap_RenderQueueListener_postRenderQueues), -1);
  rb_define_method(SwigClassRenderQueueListener.klass, "renderQueueStarted", VALUEFUNC(_wrap_RenderQueueListener_renderQueueStarted), -1);
  rb_define_method(SwigClassRenderQueueListener.klass, "renderQueueEnded", VALUEFUNC(_wrap_RenderQueueListener_renderQueueEnded), -1);
  SwigClassRenderQueueListener.mark = 0;
  SwigClassRenderQueueListener.destroy = (void (*)(void *)) free_Ogre_RenderQueueListener;
  SwigClassRenderQueueListener.trackObjects = 0;
  rb_define_singleton_method(mOgre, "RENDER_QUEUE_COUNT", VALUEFUNC(_wrap_RENDER_QUEUE_COUNT_get), 0);
  
  SwigClassCompositorInstance.klass = rb_define_class_under(mOgre, "CompositorInstance", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositorInstance, (void *) &SwigClassCompositorInstance);
  rb_define_alloc_func(SwigClassCompositorInstance.klass, _wrap_CompositorInstance_allocate);
  rb_define_method(SwigClassCompositorInstance.klass, "initialize", VALUEFUNC(_wrap_new_CompositorInstance), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "setEnabled", VALUEFUNC(_wrap_CompositorInstance_setEnabled), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getEnabled", VALUEFUNC(_wrap_CompositorInstance_getEnabled), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "setAlive", VALUEFUNC(_wrap_CompositorInstance_setAlive), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getAlive", VALUEFUNC(_wrap_CompositorInstance_getAlive), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getTextureInstanceName", VALUEFUNC(_wrap_CompositorInstance_getTextureInstanceName), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getTextureInstance", VALUEFUNC(_wrap_CompositorInstance_getTextureInstance), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getRenderTarget", VALUEFUNC(_wrap_CompositorInstance_getRenderTarget), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_compileTargetOperations", VALUEFUNC(_wrap_CompositorInstance__compileTargetOperations), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_compileOutputOperation", VALUEFUNC(_wrap_CompositorInstance__compileOutputOperation), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getCompositor", VALUEFUNC(_wrap_CompositorInstance_getCompositor), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getTechnique", VALUEFUNC(_wrap_CompositorInstance_getTechnique), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "setTechnique", VALUEFUNC(_wrap_CompositorInstance_setTechnique), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "setScheme", VALUEFUNC(_wrap_CompositorInstance_setScheme), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getScheme", VALUEFUNC(_wrap_CompositorInstance_getScheme), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "notifyResized", VALUEFUNC(_wrap_CompositorInstance_notifyResized), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "getChain", VALUEFUNC(_wrap_CompositorInstance_getChain), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "addListener", VALUEFUNC(_wrap_CompositorInstance_addListener), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "removeListener", VALUEFUNC(_wrap_CompositorInstance_removeListener), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_fireNotifyMaterialSetup", VALUEFUNC(_wrap_CompositorInstance__fireNotifyMaterialSetup), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_fireNotifyMaterialRender", VALUEFUNC(_wrap_CompositorInstance__fireNotifyMaterialRender), -1);
  rb_define_method(SwigClassCompositorInstance.klass, "_fireNotifyResourcesCreated", VALUEFUNC(_wrap_CompositorInstance__fireNotifyResourcesCreated), -1);
  SwigClassCompositorInstance.mark = 0;
  SwigClassCompositorInstance.destroy = (void (*)(void *)) free_Ogre_CompositorInstance;
  SwigClassCompositorInstance.trackObjects = 0;
  
  SwigClassCompositorChain.klass = rb_define_class_under(mOgre, "CompositorChain", ((swig_class *) SWIGTYPE_p_Ogre__RenderTargetListener->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositorChain, (void *) &SwigClassCompositorChain);
  rb_define_alloc_func(SwigClassCompositorChain.klass, _wrap_CompositorChain_allocate);
  rb_define_method(SwigClassCompositorChain.klass, "initialize", VALUEFUNC(_wrap_new_CompositorChain), -1);
  rb_define_const(SwigClassCompositorChain.klass, "LAST", SWIG_From_size_t(static_cast< size_t >(Ogre::CompositorChain::LAST)));
  rb_define_const(SwigClassCompositorChain.klass, "BEST", SWIG_From_size_t(static_cast< size_t >(Ogre::CompositorChain::BEST)));
  rb_define_method(SwigClassCompositorChain.klass, "addCompositor", VALUEFUNC(_wrap_CompositorChain_addCompositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "removeCompositor", VALUEFUNC(_wrap_CompositorChain_removeCompositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "getNumCompositors", VALUEFUNC(_wrap_CompositorChain_getNumCompositors), -1);
  rb_define_method(SwigClassCompositorChain.klass, "removeAllCompositors", VALUEFUNC(_wrap_CompositorChain_removeAllCompositors), -1);
  rb_define_method(SwigClassCompositorChain.klass, "getCompositor", VALUEFUNC(_wrap_CompositorChain_getCompositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_getOriginalSceneCompositor", VALUEFUNC(_wrap_CompositorChain__getOriginalSceneCompositor), -1);
  rb_define_method(SwigClassCompositorChain.klass, "getCompositors", VALUEFUNC(_wrap_CompositorChain_getCompositors), -1);
  rb_define_method(SwigClassCompositorChain.klass, "setCompositorEnabled", VALUEFUNC(_wrap_CompositorChain_setCompositorEnabled), -1);
  rb_define_method(SwigClassCompositorChain.klass, "preRenderTargetUpdate", VALUEFUNC(_wrap_CompositorChain_preRenderTargetUpdate), -1);
  rb_define_method(SwigClassCompositorChain.klass, "postRenderTargetUpdate", VALUEFUNC(_wrap_CompositorChain_postRenderTargetUpdate), -1);
  rb_define_method(SwigClassCompositorChain.klass, "preViewportUpdate", VALUEFUNC(_wrap_CompositorChain_preViewportUpdate), -1);
  rb_define_method(SwigClassCompositorChain.klass, "postViewportUpdate", VALUEFUNC(_wrap_CompositorChain_postViewportUpdate), -1);
  rb_define_method(SwigClassCompositorChain.klass, "viewportCameraChanged", VALUEFUNC(_wrap_CompositorChain_viewportCameraChanged), -1);
  rb_define_method(SwigClassCompositorChain.klass, "viewportDimensionsChanged", VALUEFUNC(_wrap_CompositorChain_viewportDimensionsChanged), -1);
  rb_define_method(SwigClassCompositorChain.klass, "viewportDestroyed", VALUEFUNC(_wrap_CompositorChain_viewportDestroyed), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_markDirty", VALUEFUNC(_wrap_CompositorChain__markDirty), -1);
  rb_define_method(SwigClassCompositorChain.klass, "getViewport", VALUEFUNC(_wrap_CompositorChain_getViewport), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_removeInstance", VALUEFUNC(_wrap_CompositorChain__removeInstance), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_queuedOperation", VALUEFUNC(_wrap_CompositorChain__queuedOperation), -1);
  rb_define_method(SwigClassCompositorChain.klass, "_compile", VALUEFUNC(_wrap_CompositorChain__compile), -1);
  rb_define_method(SwigClassCompositorChain.klass, "getPreviousInstance", VALUEFUNC(_wrap_CompositorChain_getPreviousInstance), -1);
  rb_define_method(SwigClassCompositorChain.klass, "getNextInstance", VALUEFUNC(_wrap_CompositorChain_getNextInstance), -1);
  SwigClassCompositorChain.mark = 0;
  SwigClassCompositorChain.destroy = (void (*)(void *)) free_Ogre_CompositorChain;
  SwigClassCompositorChain.trackObjects = 0;
  
  SwigClassCompositorLogic.klass = rb_define_class_under(mOgre, "CompositorLogic", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositorLogic, (void *) &SwigClassCompositorLogic);
  rb_define_alloc_func(SwigClassCompositorLogic.klass, _wrap_CompositorLogic_allocate);
  rb_define_method(SwigClassCompositorLogic.klass, "initialize", VALUEFUNC(_wrap_new_CompositorLogic), -1);
  rb_define_method(SwigClassCompositorLogic.klass, "compositorInstanceCreated", VALUEFUNC(_wrap_CompositorLogic_compositorInstanceCreated), -1);
  rb_define_method(SwigClassCompositorLogic.klass, "compositorInstanceDestroyed", VALUEFUNC(_wrap_CompositorLogic_compositorInstanceDestroyed), -1);
  SwigClassCompositorLogic.mark = 0;
  SwigClassCompositorLogic.destroy = (void (*)(void *)) free_Ogre_CompositorLogic;
  SwigClassCompositorLogic.trackObjects = 0;
  
  SwigClassRectangle2D.klass = rb_define_class_under(mOgre, "Rectangle2D", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Rectangle2D, (void *) &SwigClassRectangle2D);
  rb_define_alloc_func(SwigClassRectangle2D.klass, _wrap_Rectangle2D_allocate);
  rb_define_method(SwigClassRectangle2D.klass, "initialize", VALUEFUNC(_wrap_new_Rectangle2D), -1);
  rb_define_method(SwigClassRectangle2D.klass, "setCorners", VALUEFUNC(_wrap_Rectangle2D_setCorners), -1);
  rb_define_method(SwigClassRectangle2D.klass, "setNormals", VALUEFUNC(_wrap_Rectangle2D_setNormals), -1);
  rb_define_method(SwigClassRectangle2D.klass, "setUVs", VALUEFUNC(_wrap_Rectangle2D_setUVs), -1);
  rb_define_method(SwigClassRectangle2D.klass, "setDefaultUVs", VALUEFUNC(_wrap_Rectangle2D_setDefaultUVs), -1);
  rb_define_method(SwigClassRectangle2D.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_Rectangle2D_getSquaredViewDepth), -1);
  rb_define_method(SwigClassRectangle2D.klass, "getBoundingRadius", VALUEFUNC(_wrap_Rectangle2D_getBoundingRadius), -1);
  SwigClassRectangle2D.mark = 0;
  SwigClassRectangle2D.destroy = (void (*)(void *)) free_Ogre_Rectangle2D;
  SwigClassRectangle2D.trackObjects = 0;
  
  SwigClassCompositorManager.klass = rb_define_class_under(mOgre, "CompositorManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositorManager, (void *) &SwigClassCompositorManager);
  rb_define_alloc_func(SwigClassCompositorManager.klass, _wrap_CompositorManager_allocate);
  rb_define_method(SwigClassCompositorManager.klass, "initialize", VALUEFUNC(_wrap_new_CompositorManager), -1);
  rb_define_method(SwigClassCompositorManager.klass, "createImpl", VALUEFUNC(_wrap_CompositorManager_createImpl), -1);
  rb_define_method(SwigClassCompositorManager.klass, "initialise", VALUEFUNC(_wrap_CompositorManager_initialise), -1);
  rb_define_method(SwigClassCompositorManager.klass, "parseScript", VALUEFUNC(_wrap_CompositorManager_parseScript), -1);
  rb_define_method(SwigClassCompositorManager.klass, "getCompositorChain", VALUEFUNC(_wrap_CompositorManager_getCompositorChain), -1);
  rb_define_method(SwigClassCompositorManager.klass, "hasCompositorChain", VALUEFUNC(_wrap_CompositorManager_hasCompositorChain), -1);
  rb_define_method(SwigClassCompositorManager.klass, "removeCompositorChain", VALUEFUNC(_wrap_CompositorManager_removeCompositorChain), -1);
  rb_define_method(SwigClassCompositorManager.klass, "addCompositor", VALUEFUNC(_wrap_CompositorManager_addCompositor), -1);
  rb_define_method(SwigClassCompositorManager.klass, "removeCompositor", VALUEFUNC(_wrap_CompositorManager_removeCompositor), -1);
  rb_define_method(SwigClassCompositorManager.klass, "setCompositorEnabled", VALUEFUNC(_wrap_CompositorManager_setCompositorEnabled), -1);
  rb_define_method(SwigClassCompositorManager.klass, "_getTexturedRectangle2D", VALUEFUNC(_wrap_CompositorManager__getTexturedRectangle2D), -1);
  rb_define_method(SwigClassCompositorManager.klass, "removeAll", VALUEFUNC(_wrap_CompositorManager_removeAll), -1);
  rb_define_method(SwigClassCompositorManager.klass, "_reconstructAllCompositorResources", VALUEFUNC(_wrap_CompositorManager__reconstructAllCompositorResources), -1);
  rb_define_method(SwigClassCompositorManager.klass, "getPooledTexture", VALUEFUNC(_wrap_CompositorManager_getPooledTexture), -1);
  rb_define_method(SwigClassCompositorManager.klass, "freePooledTextures", VALUEFUNC(_wrap_CompositorManager_freePooledTextures), -1);
  rb_define_method(SwigClassCompositorManager.klass, "registerCompositorLogic", VALUEFUNC(_wrap_CompositorManager_registerCompositorLogic), -1);
  rb_define_method(SwigClassCompositorManager.klass, "unregisterCompositorLogic", VALUEFUNC(_wrap_CompositorManager_unregisterCompositorLogic), -1);
  rb_define_method(SwigClassCompositorManager.klass, "getCompositorLogic", VALUEFUNC(_wrap_CompositorManager_getCompositorLogic), -1);
  rb_define_method(SwigClassCompositorManager.klass, "registerCustomCompositionPass", VALUEFUNC(_wrap_CompositorManager_registerCustomCompositionPass), -1);
  rb_define_method(SwigClassCompositorManager.klass, "getCustomCompositionPass", VALUEFUNC(_wrap_CompositorManager_getCustomCompositionPass), -1);
  rb_define_singleton_method(SwigClassCompositorManager.klass, "getSingleton", VALUEFUNC(_wrap_CompositorManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassCompositorManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_CompositorManager_getSingletonPtr), -1);
  SwigClassCompositorManager.mark = 0;
  SwigClassCompositorManager.destroy = (void (*)(void *)) free_Ogre_CompositorManager;
  SwigClassCompositorManager.trackObjects = 0;
  
  SwigClassConfigFile.klass = rb_define_class_under(mOgre, "ConfigFile", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ConfigFile, (void *) &SwigClassConfigFile);
  rb_define_alloc_func(SwigClassConfigFile.klass, _wrap_ConfigFile_allocate);
  rb_define_method(SwigClassConfigFile.klass, "initialize", VALUEFUNC(_wrap_new_ConfigFile), -1);
  rb_define_method(SwigClassConfigFile.klass, "load", VALUEFUNC(_wrap_ConfigFile_load), -1);
  rb_define_method(SwigClassConfigFile.klass, "loadDirect", VALUEFUNC(_wrap_ConfigFile_loadDirect), -1);
  rb_define_method(SwigClassConfigFile.klass, "loadFromResourceSystem", VALUEFUNC(_wrap_ConfigFile_loadFromResourceSystem), -1);
  rb_define_method(SwigClassConfigFile.klass, "getSetting", VALUEFUNC(_wrap_ConfigFile_getSetting), -1);
  rb_define_method(SwigClassConfigFile.klass, "getMultiSetting", VALUEFUNC(_wrap_ConfigFile_getMultiSetting), -1);
  rb_define_method(SwigClassConfigFile.klass, "getSectionIterator", VALUEFUNC(_wrap_ConfigFile_getSectionIterator), -1);
  rb_define_method(SwigClassConfigFile.klass, "getSettingsIterator", VALUEFUNC(_wrap_ConfigFile_getSettingsIterator), -1);
  rb_define_method(SwigClassConfigFile.klass, "clear", VALUEFUNC(_wrap_ConfigFile_clear), -1);
  rb_define_method(SwigClassConfigFile.klass, "each_Settings", VALUEFUNC(_wrap_ConfigFile_each_Settings), -1);
  SwigClassConfigFile.mark = 0;
  SwigClassConfigFile.destroy = (void (*)(void *)) free_Ogre_ConfigFile;
  SwigClassConfigFile.trackObjects = 0;
  
  SwigClassFrameTimeControllerValue.klass = rb_define_class_under(mOgre, "FrameTimeControllerValue", ((swig_class *) SWIGTYPE_p_Ogre__FrameListener->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FrameTimeControllerValue, (void *) &SwigClassFrameTimeControllerValue);
  rb_define_alloc_func(SwigClassFrameTimeControllerValue.klass, _wrap_FrameTimeControllerValue_allocate);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "initialize", VALUEFUNC(_wrap_new_FrameTimeControllerValue), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "frameEnded", VALUEFUNC(_wrap_FrameTimeControllerValue_frameEnded), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "frameStarted", VALUEFUNC(_wrap_FrameTimeControllerValue_frameStarted), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "getValue", VALUEFUNC(_wrap_FrameTimeControllerValue_getValue), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "setValue", VALUEFUNC(_wrap_FrameTimeControllerValue_setValue), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "getTimeFactor", VALUEFUNC(_wrap_FrameTimeControllerValue_getTimeFactor), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "setTimeFactor", VALUEFUNC(_wrap_FrameTimeControllerValue_setTimeFactor), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "getFrameDelay", VALUEFUNC(_wrap_FrameTimeControllerValue_getFrameDelay), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "setFrameDelay", VALUEFUNC(_wrap_FrameTimeControllerValue_setFrameDelay), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "getElapsedTime", VALUEFUNC(_wrap_FrameTimeControllerValue_getElapsedTime), -1);
  rb_define_method(SwigClassFrameTimeControllerValue.klass, "setElapsedTime", VALUEFUNC(_wrap_FrameTimeControllerValue_setElapsedTime), -1);
  SwigClassFrameTimeControllerValue.mark = 0;
  SwigClassFrameTimeControllerValue.destroy = (void (*)(void *)) free_Ogre_FrameTimeControllerValue;
  SwigClassFrameTimeControllerValue.trackObjects = 0;
  
  SwigClassTextureFrameControllerValue.klass = rb_define_class_under(mOgre, "TextureFrameControllerValue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TextureFrameControllerValue, (void *) &SwigClassTextureFrameControllerValue);
  rb_define_alloc_func(SwigClassTextureFrameControllerValue.klass, _wrap_TextureFrameControllerValue_allocate);
  rb_define_method(SwigClassTextureFrameControllerValue.klass, "initialize", VALUEFUNC(_wrap_new_TextureFrameControllerValue), -1);
  rb_define_method(SwigClassTextureFrameControllerValue.klass, "getValue", VALUEFUNC(_wrap_TextureFrameControllerValue_getValue), -1);
  rb_define_method(SwigClassTextureFrameControllerValue.klass, "setValue", VALUEFUNC(_wrap_TextureFrameControllerValue_setValue), -1);
  SwigClassTextureFrameControllerValue.mark = 0;
  SwigClassTextureFrameControllerValue.destroy = (void (*)(void *)) free_Ogre_TextureFrameControllerValue;
  SwigClassTextureFrameControllerValue.trackObjects = 0;
  
  SwigClassTexCoordModifierControllerValue.klass = rb_define_class_under(mOgre, "TexCoordModifierControllerValue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TexCoordModifierControllerValue, (void *) &SwigClassTexCoordModifierControllerValue);
  rb_define_alloc_func(SwigClassTexCoordModifierControllerValue.klass, _wrap_TexCoordModifierControllerValue_allocate);
  rb_define_method(SwigClassTexCoordModifierControllerValue.klass, "initialize", VALUEFUNC(_wrap_new_TexCoordModifierControllerValue), -1);
  rb_define_method(SwigClassTexCoordModifierControllerValue.klass, "getValue", VALUEFUNC(_wrap_TexCoordModifierControllerValue_getValue), -1);
  rb_define_method(SwigClassTexCoordModifierControllerValue.klass, "setValue", VALUEFUNC(_wrap_TexCoordModifierControllerValue_setValue), -1);
  SwigClassTexCoordModifierControllerValue.mark = 0;
  SwigClassTexCoordModifierControllerValue.destroy = (void (*)(void *)) free_Ogre_TexCoordModifierControllerValue;
  SwigClassTexCoordModifierControllerValue.trackObjects = 0;
  
  SwigClassFloatGpuParameterControllerValue.klass = rb_define_class_under(mOgre, "FloatGpuParameterControllerValue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FloatGpuParameterControllerValue, (void *) &SwigClassFloatGpuParameterControllerValue);
  rb_define_alloc_func(SwigClassFloatGpuParameterControllerValue.klass, _wrap_FloatGpuParameterControllerValue_allocate);
  rb_define_method(SwigClassFloatGpuParameterControllerValue.klass, "initialize", VALUEFUNC(_wrap_new_FloatGpuParameterControllerValue), -1);
  rb_define_method(SwigClassFloatGpuParameterControllerValue.klass, "getValue", VALUEFUNC(_wrap_FloatGpuParameterControllerValue_getValue), -1);
  rb_define_method(SwigClassFloatGpuParameterControllerValue.klass, "setValue", VALUEFUNC(_wrap_FloatGpuParameterControllerValue_setValue), -1);
  SwigClassFloatGpuParameterControllerValue.mark = 0;
  SwigClassFloatGpuParameterControllerValue.destroy = (void (*)(void *)) free_Ogre_FloatGpuParameterControllerValue;
  SwigClassFloatGpuParameterControllerValue.trackObjects = 0;
  
  SwigClassPassthroughControllerFunction.klass = rb_define_class_under(mOgre, "PassthroughControllerFunction", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PassthroughControllerFunction, (void *) &SwigClassPassthroughControllerFunction);
  rb_define_alloc_func(SwigClassPassthroughControllerFunction.klass, _wrap_PassthroughControllerFunction_allocate);
  rb_define_method(SwigClassPassthroughControllerFunction.klass, "initialize", VALUEFUNC(_wrap_new_PassthroughControllerFunction), -1);
  rb_define_method(SwigClassPassthroughControllerFunction.klass, "calculate", VALUEFUNC(_wrap_PassthroughControllerFunction_calculate), -1);
  SwigClassPassthroughControllerFunction.mark = 0;
  SwigClassPassthroughControllerFunction.destroy = (void (*)(void *)) free_Ogre_PassthroughControllerFunction;
  SwigClassPassthroughControllerFunction.trackObjects = 0;
  
  SwigClassAnimationControllerFunction.klass = rb_define_class_under(mOgre, "AnimationControllerFunction", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AnimationControllerFunction, (void *) &SwigClassAnimationControllerFunction);
  rb_define_alloc_func(SwigClassAnimationControllerFunction.klass, _wrap_AnimationControllerFunction_allocate);
  rb_define_method(SwigClassAnimationControllerFunction.klass, "initialize", VALUEFUNC(_wrap_new_AnimationControllerFunction), -1);
  rb_define_method(SwigClassAnimationControllerFunction.klass, "calculate", VALUEFUNC(_wrap_AnimationControllerFunction_calculate), -1);
  rb_define_method(SwigClassAnimationControllerFunction.klass, "setTime", VALUEFUNC(_wrap_AnimationControllerFunction_setTime), -1);
  rb_define_method(SwigClassAnimationControllerFunction.klass, "setSequenceTime", VALUEFUNC(_wrap_AnimationControllerFunction_setSequenceTime), -1);
  SwigClassAnimationControllerFunction.mark = 0;
  SwigClassAnimationControllerFunction.destroy = (void (*)(void *)) free_Ogre_AnimationControllerFunction;
  SwigClassAnimationControllerFunction.trackObjects = 0;
  
  SwigClassScaleControllerFunction.klass = rb_define_class_under(mOgre, "ScaleControllerFunction", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScaleControllerFunction, (void *) &SwigClassScaleControllerFunction);
  rb_define_alloc_func(SwigClassScaleControllerFunction.klass, _wrap_ScaleControllerFunction_allocate);
  rb_define_method(SwigClassScaleControllerFunction.klass, "initialize", VALUEFUNC(_wrap_new_ScaleControllerFunction), -1);
  rb_define_method(SwigClassScaleControllerFunction.klass, "calculate", VALUEFUNC(_wrap_ScaleControllerFunction_calculate), -1);
  SwigClassScaleControllerFunction.mark = 0;
  SwigClassScaleControllerFunction.destroy = (void (*)(void *)) free_Ogre_ScaleControllerFunction;
  SwigClassScaleControllerFunction.trackObjects = 0;
  
  SwigClassWaveformControllerFunction.klass = rb_define_class_under(mOgre, "WaveformControllerFunction", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__WaveformControllerFunction, (void *) &SwigClassWaveformControllerFunction);
  rb_define_alloc_func(SwigClassWaveformControllerFunction.klass, _wrap_WaveformControllerFunction_allocate);
  rb_define_method(SwigClassWaveformControllerFunction.klass, "initialize", VALUEFUNC(_wrap_new_WaveformControllerFunction), -1);
  rb_define_method(SwigClassWaveformControllerFunction.klass, "calculate", VALUEFUNC(_wrap_WaveformControllerFunction_calculate), -1);
  SwigClassWaveformControllerFunction.mark = 0;
  SwigClassWaveformControllerFunction.destroy = (void (*)(void *)) free_Ogre_WaveformControllerFunction;
  SwigClassWaveformControllerFunction.trackObjects = 0;
  
  SwigClassControllerManager.klass = rb_define_class_under(mOgre, "ControllerManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ControllerManager, (void *) &SwigClassControllerManager);
  rb_define_alloc_func(SwigClassControllerManager.klass, _wrap_ControllerManager_allocate);
  rb_define_method(SwigClassControllerManager.klass, "initialize", VALUEFUNC(_wrap_new_ControllerManager), -1);
  rb_define_method(SwigClassControllerManager.klass, "createController", VALUEFUNC(_wrap_ControllerManager_createController), -1);
  rb_define_method(SwigClassControllerManager.klass, "createFrameTimePassthroughController", VALUEFUNC(_wrap_ControllerManager_createFrameTimePassthroughController), -1);
  rb_define_method(SwigClassControllerManager.klass, "clearControllers", VALUEFUNC(_wrap_ControllerManager_clearControllers), -1);
  rb_define_method(SwigClassControllerManager.klass, "updateAllControllers", VALUEFUNC(_wrap_ControllerManager_updateAllControllers), -1);
  rb_define_method(SwigClassControllerManager.klass, "getFrameTimeSource", VALUEFUNC(_wrap_ControllerManager_getFrameTimeSource), -1);
  rb_define_method(SwigClassControllerManager.klass, "getPassthroughControllerFunction", VALUEFUNC(_wrap_ControllerManager_getPassthroughControllerFunction), -1);
  rb_define_method(SwigClassControllerManager.klass, "createTextureAnimator", VALUEFUNC(_wrap_ControllerManager_createTextureAnimator), -1);
  rb_define_method(SwigClassControllerManager.klass, "createTextureUVScroller", VALUEFUNC(_wrap_ControllerManager_createTextureUVScroller), -1);
  rb_define_method(SwigClassControllerManager.klass, "createTextureUScroller", VALUEFUNC(_wrap_ControllerManager_createTextureUScroller), -1);
  rb_define_method(SwigClassControllerManager.klass, "createTextureVScroller", VALUEFUNC(_wrap_ControllerManager_createTextureVScroller), -1);
  rb_define_method(SwigClassControllerManager.klass, "createTextureRotater", VALUEFUNC(_wrap_ControllerManager_createTextureRotater), -1);
  rb_define_method(SwigClassControllerManager.klass, "createTextureWaveTransformer", VALUEFUNC(_wrap_ControllerManager_createTextureWaveTransformer), -1);
  rb_define_method(SwigClassControllerManager.klass, "createGpuProgramTimerParam", VALUEFUNC(_wrap_ControllerManager_createGpuProgramTimerParam), -1);
  rb_define_method(SwigClassControllerManager.klass, "destroyController", VALUEFUNC(_wrap_ControllerManager_destroyController), -1);
  rb_define_method(SwigClassControllerManager.klass, "getTimeFactor", VALUEFUNC(_wrap_ControllerManager_getTimeFactor), -1);
  rb_define_method(SwigClassControllerManager.klass, "setTimeFactor", VALUEFUNC(_wrap_ControllerManager_setTimeFactor), -1);
  rb_define_method(SwigClassControllerManager.klass, "getFrameDelay", VALUEFUNC(_wrap_ControllerManager_getFrameDelay), -1);
  rb_define_method(SwigClassControllerManager.klass, "setFrameDelay", VALUEFUNC(_wrap_ControllerManager_setFrameDelay), -1);
  rb_define_method(SwigClassControllerManager.klass, "getElapsedTime", VALUEFUNC(_wrap_ControllerManager_getElapsedTime), -1);
  rb_define_method(SwigClassControllerManager.klass, "setElapsedTime", VALUEFUNC(_wrap_ControllerManager_setElapsedTime), -1);
  rb_define_singleton_method(SwigClassControllerManager.klass, "getSingleton", VALUEFUNC(_wrap_ControllerManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassControllerManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_ControllerManager_getSingletonPtr), -1);
  SwigClassControllerManager.mark = 0;
  SwigClassControllerManager.destroy = (void (*)(void *)) free_Ogre_ControllerManager;
  SwigClassControllerManager.trackObjects = 0;
  
  SwigClassPolygon.klass = rb_define_class_under(mOgre, "Polygon", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Polygon, (void *) &SwigClassPolygon);
  rb_define_alloc_func(SwigClassPolygon.klass, _wrap_Polygon_allocate);
  rb_define_method(SwigClassPolygon.klass, "initialize", VALUEFUNC(_wrap_new_Polygon), -1);
  rb_define_method(SwigClassPolygon.klass, "insertVertex", VALUEFUNC(_wrap_Polygon_insertVertex), -1);
  rb_define_method(SwigClassPolygon.klass, "getVertex", VALUEFUNC(_wrap_Polygon_getVertex), -1);
  rb_define_method(SwigClassPolygon.klass, "setVertex", VALUEFUNC(_wrap_Polygon_setVertex), -1);
  rb_define_method(SwigClassPolygon.klass, "removeDuplicates", VALUEFUNC(_wrap_Polygon_removeDuplicates), -1);
  rb_define_method(SwigClassPolygon.klass, "getVertexCount", VALUEFUNC(_wrap_Polygon_getVertexCount), -1);
  rb_define_method(SwigClassPolygon.klass, "getNormal", VALUEFUNC(_wrap_Polygon_getNormal), -1);
  rb_define_method(SwigClassPolygon.klass, "deleteVertex", VALUEFUNC(_wrap_Polygon_deleteVertex), -1);
  rb_define_method(SwigClassPolygon.klass, "isPointInside", VALUEFUNC(_wrap_Polygon_isPointInside), -1);
  rb_define_method(SwigClassPolygon.klass, "storeEdges", VALUEFUNC(_wrap_Polygon_storeEdges), -1);
  rb_define_method(SwigClassPolygon.klass, "reset", VALUEFUNC(_wrap_Polygon_reset), -1);
  rb_define_method(SwigClassPolygon.klass, "==", VALUEFUNC(_wrap_Polygon___eq__), -1);
  SwigClassPolygon.mark = 0;
  SwigClassPolygon.destroy = (void (*)(void *)) free_Ogre_Polygon;
  SwigClassPolygon.trackObjects = 0;
  
  SwigClassConvexBody.klass = rb_define_class_under(mOgre, "ConvexBody", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ConvexBody, (void *) &SwigClassConvexBody);
  rb_define_alloc_func(SwigClassConvexBody.klass, _wrap_ConvexBody_allocate);
  rb_define_method(SwigClassConvexBody.klass, "initialize", VALUEFUNC(_wrap_new_ConvexBody), -1);
  rb_define_method(SwigClassConvexBody.klass, "define", VALUEFUNC(_wrap_ConvexBody_define), -1);
  rb_define_method(SwigClassConvexBody.klass, "clip", VALUEFUNC(_wrap_ConvexBody_clip), -1);
  rb_define_method(SwigClassConvexBody.klass, "extend", VALUEFUNC(_wrap_ConvexBody_extend), -1);
  rb_define_method(SwigClassConvexBody.klass, "reset", VALUEFUNC(_wrap_ConvexBody_reset), -1);
  rb_define_method(SwigClassConvexBody.klass, "getPolygonCount", VALUEFUNC(_wrap_ConvexBody_getPolygonCount), -1);
  rb_define_method(SwigClassConvexBody.klass, "getVertexCount", VALUEFUNC(_wrap_ConvexBody_getVertexCount), -1);
  rb_define_method(SwigClassConvexBody.klass, "getPolygon", VALUEFUNC(_wrap_ConvexBody_getPolygon), -1);
  rb_define_method(SwigClassConvexBody.klass, "getVertex", VALUEFUNC(_wrap_ConvexBody_getVertex), -1);
  rb_define_method(SwigClassConvexBody.klass, "getNormal", VALUEFUNC(_wrap_ConvexBody_getNormal), -1);
  rb_define_method(SwigClassConvexBody.klass, "getAABB", VALUEFUNC(_wrap_ConvexBody_getAABB), -1);
  rb_define_method(SwigClassConvexBody.klass, "hasClosedHull", VALUEFUNC(_wrap_ConvexBody_hasClosedHull), -1);
  rb_define_method(SwigClassConvexBody.klass, "mergePolygons", VALUEFUNC(_wrap_ConvexBody_mergePolygons), -1);
  rb_define_method(SwigClassConvexBody.klass, "==", VALUEFUNC(_wrap_ConvexBody___eq__), -1);
  rb_define_method(SwigClassConvexBody.klass, "logInfo", VALUEFUNC(_wrap_ConvexBody_logInfo), -1);
  rb_define_singleton_method(SwigClassConvexBody.klass, "_initialisePool", VALUEFUNC(_wrap_ConvexBody__initialisePool), -1);
  rb_define_singleton_method(SwigClassConvexBody.klass, "_destroyPool", VALUEFUNC(_wrap_ConvexBody__destroyPool), -1);
  SwigClassConvexBody.mark = 0;
  SwigClassConvexBody.destroy = (void (*)(void *)) free_Ogre_ConvexBody;
  SwigClassConvexBody.trackObjects = 0;
  
  SwigClassCustomCompositionPass.klass = rb_define_class_under(mOgre, "CustomCompositionPass", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CustomCompositionPass, (void *) &SwigClassCustomCompositionPass);
  rb_undef_alloc_func(SwigClassCustomCompositionPass.klass);
  rb_define_method(SwigClassCustomCompositionPass.klass, "createOperation", VALUEFUNC(_wrap_CustomCompositionPass_createOperation), -1);
  SwigClassCustomCompositionPass.mark = 0;
  SwigClassCustomCompositionPass.trackObjects = 0;
  
  SwigClassImageCodec.klass = rb_define_class_under(mOgre, "ImageCodec", ((swig_class *) SWIGTYPE_p_Ogre__Codec->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ImageCodec, (void *) &SwigClassImageCodec);
  rb_undef_alloc_func(SwigClassImageCodec.klass);
  rb_define_method(SwigClassImageCodec.klass, "getDataType", VALUEFUNC(_wrap_ImageCodec_getDataType), -1);
  SwigClassImageCodec.mark = 0;
  SwigClassImageCodec.destroy = (void (*)(void *)) free_Ogre_ImageCodec;
  SwigClassImageCodec.trackObjects = 0;
  
  SwigClassDDSCodec.klass = rb_define_class_under(mOgre, "DDSCodec", ((swig_class *) SWIGTYPE_p_Ogre__ImageCodec->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DDSCodec, (void *) &SwigClassDDSCodec);
  rb_define_alloc_func(SwigClassDDSCodec.klass, _wrap_DDSCodec_allocate);
  rb_define_method(SwigClassDDSCodec.klass, "initialize", VALUEFUNC(_wrap_new_DDSCodec), -1);
  rb_define_method(SwigClassDDSCodec.klass, "code", VALUEFUNC(_wrap_DDSCodec_code), -1);
  rb_define_method(SwigClassDDSCodec.klass, "codeToFile", VALUEFUNC(_wrap_DDSCodec_codeToFile), -1);
  rb_define_method(SwigClassDDSCodec.klass, "decode", VALUEFUNC(_wrap_DDSCodec_decode), -1);
  rb_define_method(SwigClassDDSCodec.klass, "magicNumberToFileExt", VALUEFUNC(_wrap_DDSCodec_magicNumberToFileExt), -1);
  rb_define_method(SwigClassDDSCodec.klass, "getType", VALUEFUNC(_wrap_DDSCodec_getType), -1);
  rb_define_singleton_method(SwigClassDDSCodec.klass, "startup", VALUEFUNC(_wrap_DDSCodec_startup), -1);
  rb_define_singleton_method(SwigClassDDSCodec.klass, "shutdown", VALUEFUNC(_wrap_DDSCodec_shutdown), -1);
  SwigClassDDSCodec.mark = 0;
  SwigClassDDSCodec.destroy = (void (*)(void *)) free_Ogre_DDSCodec;
  SwigClassDDSCodec.trackObjects = 0;
  
  SwigClassRenderToVertexBuffer.klass = rb_define_class_under(mOgre, "RenderToVertexBuffer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderToVertexBuffer, (void *) &SwigClassRenderToVertexBuffer);
  rb_undef_alloc_func(SwigClassRenderToVertexBuffer.klass);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "getVertexDeclaration", VALUEFUNC(_wrap_RenderToVertexBuffer_getVertexDeclaration), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "getMaxVertexCount", VALUEFUNC(_wrap_RenderToVertexBuffer_getMaxVertexCount), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "setMaxVertexCount", VALUEFUNC(_wrap_RenderToVertexBuffer_setMaxVertexCount), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "getOperationType", VALUEFUNC(_wrap_RenderToVertexBuffer_getOperationType), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "setOperationType", VALUEFUNC(_wrap_RenderToVertexBuffer_setOperationType), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "setResetsEveryUpdate", VALUEFUNC(_wrap_RenderToVertexBuffer_setResetsEveryUpdate), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "getResetsEveryUpdate", VALUEFUNC(_wrap_RenderToVertexBuffer_getResetsEveryUpdate), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "getRenderOperation", VALUEFUNC(_wrap_RenderToVertexBuffer_getRenderOperation), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "update", VALUEFUNC(_wrap_RenderToVertexBuffer_update), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "reset", VALUEFUNC(_wrap_RenderToVertexBuffer_reset), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "setSourceRenderable", VALUEFUNC(_wrap_RenderToVertexBuffer_setSourceRenderable), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "getSourceRenderable", VALUEFUNC(_wrap_RenderToVertexBuffer_getSourceRenderable), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "getRenderToBufferMaterial", VALUEFUNC(_wrap_RenderToVertexBuffer_getRenderToBufferMaterial), -1);
  rb_define_method(SwigClassRenderToVertexBuffer.klass, "setRenderToBufferMaterialName", VALUEFUNC(_wrap_RenderToVertexBuffer_setRenderToBufferMaterialName), -1);
  SwigClassRenderToVertexBuffer.mark = 0;
  SwigClassRenderToVertexBuffer.destroy = (void (*)(void *)) free_Ogre_RenderToVertexBuffer;
  SwigClassRenderToVertexBuffer.trackObjects = 0;
  
  SwigClassHardwareBufferLicensee.klass = rb_define_class_under(mOgre, "HardwareBufferLicensee", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareBufferLicensee, (void *) &SwigClassHardwareBufferLicensee);
  rb_undef_alloc_func(SwigClassHardwareBufferLicensee.klass);
  rb_define_method(SwigClassHardwareBufferLicensee.klass, "licenseExpired", VALUEFUNC(_wrap_HardwareBufferLicensee_licenseExpired), -1);
  SwigClassHardwareBufferLicensee.mark = 0;
  SwigClassHardwareBufferLicensee.destroy = (void (*)(void *)) free_Ogre_HardwareBufferLicensee;
  SwigClassHardwareBufferLicensee.trackObjects = 0;
  
  SwigClassTempBlendedBufferInfo.klass = rb_define_class_under(mOgre, "TempBlendedBufferInfo", ((swig_class *) SWIGTYPE_p_Ogre__HardwareBufferLicensee->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TempBlendedBufferInfo, (void *) &SwigClassTempBlendedBufferInfo);
  rb_define_alloc_func(SwigClassTempBlendedBufferInfo.klass, _wrap_TempBlendedBufferInfo_allocate);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "initialize", VALUEFUNC(_wrap_new_TempBlendedBufferInfo), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "extractFrom", VALUEFUNC(_wrap_TempBlendedBufferInfo_extractFrom), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "checkoutTempCopies", VALUEFUNC(_wrap_TempBlendedBufferInfo_checkoutTempCopies), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "bindTempCopies", VALUEFUNC(_wrap_TempBlendedBufferInfo_bindTempCopies), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "licenseExpired", VALUEFUNC(_wrap_TempBlendedBufferInfo_licenseExpired), -1);
  rb_define_method(SwigClassTempBlendedBufferInfo.klass, "buffersCheckedOut", VALUEFUNC(_wrap_TempBlendedBufferInfo_buffersCheckedOut), -1);
  SwigClassTempBlendedBufferInfo.mark = 0;
  SwigClassTempBlendedBufferInfo.destroy = (void (*)(void *)) free_Ogre_TempBlendedBufferInfo;
  SwigClassTempBlendedBufferInfo.trackObjects = 0;
  
  SwigClassHardwareBufferManagerBase.klass = rb_define_class_under(mOgre, "HardwareBufferManagerBase", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareBufferManagerBase, (void *) &SwigClassHardwareBufferManagerBase);
  rb_undef_alloc_func(SwigClassHardwareBufferManagerBase.klass);
  rb_define_const(SwigClassHardwareBufferManagerBase.klass, "BLT_MANUAL_RELEASE", SWIG_From_int(static_cast< int >(Ogre::HardwareBufferManagerBase::BLT_MANUAL_RELEASE)));
  rb_define_const(SwigClassHardwareBufferManagerBase.klass, "BLT_AUTOMATIC_RELEASE", SWIG_From_int(static_cast< int >(Ogre::HardwareBufferManagerBase::BLT_AUTOMATIC_RELEASE)));
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "createVertexBuffer", VALUEFUNC(_wrap_HardwareBufferManagerBase_createVertexBuffer), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "createIndexBuffer", VALUEFUNC(_wrap_HardwareBufferManagerBase_createIndexBuffer), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "createRenderToVertexBuffer", VALUEFUNC(_wrap_HardwareBufferManagerBase_createRenderToVertexBuffer), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "createVertexDeclaration", VALUEFUNC(_wrap_HardwareBufferManagerBase_createVertexDeclaration), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "destroyVertexDeclaration", VALUEFUNC(_wrap_HardwareBufferManagerBase_destroyVertexDeclaration), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "createVertexBufferBinding", VALUEFUNC(_wrap_HardwareBufferManagerBase_createVertexBufferBinding), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "destroyVertexBufferBinding", VALUEFUNC(_wrap_HardwareBufferManagerBase_destroyVertexBufferBinding), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "registerVertexBufferSourceAndCopy", VALUEFUNC(_wrap_HardwareBufferManagerBase_registerVertexBufferSourceAndCopy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "allocateVertexBufferCopy", VALUEFUNC(_wrap_HardwareBufferManagerBase_allocateVertexBufferCopy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "releaseVertexBufferCopy", VALUEFUNC(_wrap_HardwareBufferManagerBase_releaseVertexBufferCopy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "touchVertexBufferCopy", VALUEFUNC(_wrap_HardwareBufferManagerBase_touchVertexBufferCopy), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_freeUnusedBufferCopies", VALUEFUNC(_wrap_HardwareBufferManagerBase__freeUnusedBufferCopies), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_releaseBufferCopies", VALUEFUNC(_wrap_HardwareBufferManagerBase__releaseBufferCopies), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_forceReleaseBufferCopies", VALUEFUNC(_wrap_HardwareBufferManagerBase__forceReleaseBufferCopies), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_notifyVertexBufferDestroyed", VALUEFUNC(_wrap_HardwareBufferManagerBase__notifyVertexBufferDestroyed), -1);
  rb_define_method(SwigClassHardwareBufferManagerBase.klass, "_notifyIndexBufferDestroyed", VALUEFUNC(_wrap_HardwareBufferManagerBase__notifyIndexBufferDestroyed), -1);
  SwigClassHardwareBufferManagerBase.mark = 0;
  SwigClassHardwareBufferManagerBase.destroy = (void (*)(void *)) free_Ogre_HardwareBufferManagerBase;
  SwigClassHardwareBufferManagerBase.trackObjects = 0;
  
  SwigClassHardwareBufferManager.klass = rb_define_class_under(mOgre, "HardwareBufferManager", ((swig_class *) SWIGTYPE_p_Ogre__HardwareBufferManagerBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareBufferManager, (void *) &SwigClassHardwareBufferManager);
  rb_define_alloc_func(SwigClassHardwareBufferManager.klass, _wrap_HardwareBufferManager_allocate);
  rb_define_method(SwigClassHardwareBufferManager.klass, "initialize", VALUEFUNC(_wrap_new_HardwareBufferManager), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "createVertexBuffer", VALUEFUNC(_wrap_HardwareBufferManager_createVertexBuffer), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "createIndexBuffer", VALUEFUNC(_wrap_HardwareBufferManager_createIndexBuffer), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "createRenderToVertexBuffer", VALUEFUNC(_wrap_HardwareBufferManager_createRenderToVertexBuffer), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "createVertexDeclaration", VALUEFUNC(_wrap_HardwareBufferManager_createVertexDeclaration), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "destroyVertexDeclaration", VALUEFUNC(_wrap_HardwareBufferManager_destroyVertexDeclaration), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "createVertexBufferBinding", VALUEFUNC(_wrap_HardwareBufferManager_createVertexBufferBinding), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "destroyVertexBufferBinding", VALUEFUNC(_wrap_HardwareBufferManager_destroyVertexBufferBinding), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "registerVertexBufferSourceAndCopy", VALUEFUNC(_wrap_HardwareBufferManager_registerVertexBufferSourceAndCopy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "allocateVertexBufferCopy", VALUEFUNC(_wrap_HardwareBufferManager_allocateVertexBufferCopy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "releaseVertexBufferCopy", VALUEFUNC(_wrap_HardwareBufferManager_releaseVertexBufferCopy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "touchVertexBufferCopy", VALUEFUNC(_wrap_HardwareBufferManager_touchVertexBufferCopy), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_freeUnusedBufferCopies", VALUEFUNC(_wrap_HardwareBufferManager__freeUnusedBufferCopies), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_releaseBufferCopies", VALUEFUNC(_wrap_HardwareBufferManager__releaseBufferCopies), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_forceReleaseBufferCopies", VALUEFUNC(_wrap_HardwareBufferManager__forceReleaseBufferCopies), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_notifyVertexBufferDestroyed", VALUEFUNC(_wrap_HardwareBufferManager__notifyVertexBufferDestroyed), -1);
  rb_define_method(SwigClassHardwareBufferManager.klass, "_notifyIndexBufferDestroyed", VALUEFUNC(_wrap_HardwareBufferManager__notifyIndexBufferDestroyed), -1);
  rb_define_singleton_method(SwigClassHardwareBufferManager.klass, "getSingleton", VALUEFUNC(_wrap_HardwareBufferManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassHardwareBufferManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_HardwareBufferManager_getSingletonPtr), -1);
  SwigClassHardwareBufferManager.mark = 0;
  SwigClassHardwareBufferManager.destroy = (void (*)(void *)) free_Ogre_HardwareBufferManager;
  SwigClassHardwareBufferManager.trackObjects = 0;
  
  SwigClassDefaultHardwareVertexBuffer.klass = rb_define_class_under(mOgre, "DefaultHardwareVertexBuffer", ((swig_class *) SWIGTYPE_p_Ogre__HardwareVertexBuffer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultHardwareVertexBuffer, (void *) &SwigClassDefaultHardwareVertexBuffer);
  rb_define_alloc_func(SwigClassDefaultHardwareVertexBuffer.klass, _wrap_DefaultHardwareVertexBuffer_allocate);
  rb_define_method(SwigClassDefaultHardwareVertexBuffer.klass, "initialize", VALUEFUNC(_wrap_new_DefaultHardwareVertexBuffer), -1);
  rb_define_method(SwigClassDefaultHardwareVertexBuffer.klass, "readData", VALUEFUNC(_wrap_DefaultHardwareVertexBuffer_readData), -1);
  rb_define_method(SwigClassDefaultHardwareVertexBuffer.klass, "writeData", VALUEFUNC(_wrap_DefaultHardwareVertexBuffer_writeData), -1);
  rb_define_method(SwigClassDefaultHardwareVertexBuffer.klass, "lock", VALUEFUNC(_wrap_DefaultHardwareVertexBuffer_lock), -1);
  rb_define_method(SwigClassDefaultHardwareVertexBuffer.klass, "unlock", VALUEFUNC(_wrap_DefaultHardwareVertexBuffer_unlock), -1);
  SwigClassDefaultHardwareVertexBuffer.mark = 0;
  SwigClassDefaultHardwareVertexBuffer.destroy = (void (*)(void *)) free_Ogre_DefaultHardwareVertexBuffer;
  SwigClassDefaultHardwareVertexBuffer.trackObjects = 0;
  
  SwigClassDefaultHardwareIndexBuffer.klass = rb_define_class_under(mOgre, "DefaultHardwareIndexBuffer", ((swig_class *) SWIGTYPE_p_Ogre__HardwareIndexBuffer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultHardwareIndexBuffer, (void *) &SwigClassDefaultHardwareIndexBuffer);
  rb_define_alloc_func(SwigClassDefaultHardwareIndexBuffer.klass, _wrap_DefaultHardwareIndexBuffer_allocate);
  rb_define_method(SwigClassDefaultHardwareIndexBuffer.klass, "initialize", VALUEFUNC(_wrap_new_DefaultHardwareIndexBuffer), -1);
  rb_define_method(SwigClassDefaultHardwareIndexBuffer.klass, "readData", VALUEFUNC(_wrap_DefaultHardwareIndexBuffer_readData), -1);
  rb_define_method(SwigClassDefaultHardwareIndexBuffer.klass, "writeData", VALUEFUNC(_wrap_DefaultHardwareIndexBuffer_writeData), -1);
  rb_define_method(SwigClassDefaultHardwareIndexBuffer.klass, "lock", VALUEFUNC(_wrap_DefaultHardwareIndexBuffer_lock), -1);
  rb_define_method(SwigClassDefaultHardwareIndexBuffer.klass, "unlock", VALUEFUNC(_wrap_DefaultHardwareIndexBuffer_unlock), -1);
  SwigClassDefaultHardwareIndexBuffer.mark = 0;
  SwigClassDefaultHardwareIndexBuffer.destroy = (void (*)(void *)) free_Ogre_DefaultHardwareIndexBuffer;
  SwigClassDefaultHardwareIndexBuffer.trackObjects = 0;
  
  SwigClassDefaultHardwareBufferManagerBase.klass = rb_define_class_under(mOgre, "DefaultHardwareBufferManagerBase", ((swig_class *) SWIGTYPE_p_Ogre__HardwareBufferManagerBase->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultHardwareBufferManagerBase, (void *) &SwigClassDefaultHardwareBufferManagerBase);
  rb_define_alloc_func(SwigClassDefaultHardwareBufferManagerBase.klass, _wrap_DefaultHardwareBufferManagerBase_allocate);
  rb_define_method(SwigClassDefaultHardwareBufferManagerBase.klass, "initialize", VALUEFUNC(_wrap_new_DefaultHardwareBufferManagerBase), -1);
  rb_define_method(SwigClassDefaultHardwareBufferManagerBase.klass, "createVertexBuffer", VALUEFUNC(_wrap_DefaultHardwareBufferManagerBase_createVertexBuffer), -1);
  rb_define_method(SwigClassDefaultHardwareBufferManagerBase.klass, "createIndexBuffer", VALUEFUNC(_wrap_DefaultHardwareBufferManagerBase_createIndexBuffer), -1);
  rb_define_method(SwigClassDefaultHardwareBufferManagerBase.klass, "createRenderToVertexBuffer", VALUEFUNC(_wrap_DefaultHardwareBufferManagerBase_createRenderToVertexBuffer), -1);
  SwigClassDefaultHardwareBufferManagerBase.mark = 0;
  SwigClassDefaultHardwareBufferManagerBase.destroy = (void (*)(void *)) free_Ogre_DefaultHardwareBufferManagerBase;
  SwigClassDefaultHardwareBufferManagerBase.trackObjects = 0;
  
  SwigClassDefaultHardwareBufferManager.klass = rb_define_class_under(mOgre, "DefaultHardwareBufferManager", ((swig_class *) SWIGTYPE_p_Ogre__HardwareBufferManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultHardwareBufferManager, (void *) &SwigClassDefaultHardwareBufferManager);
  rb_define_alloc_func(SwigClassDefaultHardwareBufferManager.klass, _wrap_DefaultHardwareBufferManager_allocate);
  rb_define_method(SwigClassDefaultHardwareBufferManager.klass, "initialize", VALUEFUNC(_wrap_new_DefaultHardwareBufferManager), -1);
  SwigClassDefaultHardwareBufferManager.mark = 0;
  SwigClassDefaultHardwareBufferManager.destroy = (void (*)(void *)) free_Ogre_DefaultHardwareBufferManager;
  SwigClassDefaultHardwareBufferManager.trackObjects = 0;
  
  SwigClassDeflateStream.klass = rb_define_class_under(mOgre, "DeflateStream", ((swig_class *) SWIGTYPE_p_Ogre__DataStream->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DeflateStream, (void *) &SwigClassDeflateStream);
  rb_define_alloc_func(SwigClassDeflateStream.klass, _wrap_DeflateStream_allocate);
  rb_define_method(SwigClassDeflateStream.klass, "initialize", VALUEFUNC(_wrap_new_DeflateStream), -1);
  rb_define_method(SwigClassDeflateStream.klass, "isCompressedStreamValid", VALUEFUNC(_wrap_DeflateStream_isCompressedStreamValid), -1);
  rb_define_method(SwigClassDeflateStream.klass, "read", VALUEFUNC(_wrap_DeflateStream_read), -1);
  rb_define_method(SwigClassDeflateStream.klass, "write", VALUEFUNC(_wrap_DeflateStream_write), -1);
  rb_define_method(SwigClassDeflateStream.klass, "skip", VALUEFUNC(_wrap_DeflateStream_skip), -1);
  rb_define_method(SwigClassDeflateStream.klass, "seek", VALUEFUNC(_wrap_DeflateStream_seek), -1);
  rb_define_method(SwigClassDeflateStream.klass, "tell", VALUEFUNC(_wrap_DeflateStream_tell), -1);
  rb_define_method(SwigClassDeflateStream.klass, "eof", VALUEFUNC(_wrap_DeflateStream_eof), -1);
  rb_define_method(SwigClassDeflateStream.klass, "close", VALUEFUNC(_wrap_DeflateStream_close), -1);
  SwigClassDeflateStream.mark = 0;
  SwigClassDeflateStream.destroy = (void (*)(void *)) free_Ogre_DeflateStream;
  SwigClassDeflateStream.trackObjects = 0;
  
  SwigClassDepthBuffer.klass = rb_define_class_under(mOgre, "DepthBuffer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DepthBuffer, (void *) &SwigClassDepthBuffer);
  rb_define_alloc_func(SwigClassDepthBuffer.klass, _wrap_DepthBuffer_allocate);
  rb_define_method(SwigClassDepthBuffer.klass, "initialize", VALUEFUNC(_wrap_new_DepthBuffer), -1);
  rb_define_const(SwigClassDepthBuffer.klass, "POOL_NO_DEPTH", SWIG_From_int(static_cast< int >(Ogre::DepthBuffer::POOL_NO_DEPTH)));
  rb_define_const(SwigClassDepthBuffer.klass, "POOL_MANUAL_USAGE", SWIG_From_int(static_cast< int >(Ogre::DepthBuffer::POOL_MANUAL_USAGE)));
  rb_define_const(SwigClassDepthBuffer.klass, "POOL_DEFAULT", SWIG_From_int(static_cast< int >(Ogre::DepthBuffer::POOL_DEFAULT)));
  rb_define_method(SwigClassDepthBuffer.klass, "_setPoolId", VALUEFUNC(_wrap_DepthBuffer__setPoolId), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "getPoolId", VALUEFUNC(_wrap_DepthBuffer_getPoolId), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "getBitDepth", VALUEFUNC(_wrap_DepthBuffer_getBitDepth), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "getWidth", VALUEFUNC(_wrap_DepthBuffer_getWidth), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "getHeight", VALUEFUNC(_wrap_DepthBuffer_getHeight), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "getFsaa", VALUEFUNC(_wrap_DepthBuffer_getFsaa), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "getFsaaHint", VALUEFUNC(_wrap_DepthBuffer_getFsaaHint), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "isManual", VALUEFUNC(_wrap_DepthBuffer_isManual), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "isCompatible", VALUEFUNC(_wrap_DepthBuffer_isCompatible), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "_notifyRenderTargetAttached", VALUEFUNC(_wrap_DepthBuffer__notifyRenderTargetAttached), -1);
  rb_define_method(SwigClassDepthBuffer.klass, "_notifyRenderTargetDetached", VALUEFUNC(_wrap_DepthBuffer__notifyRenderTargetDetached), -1);
  SwigClassDepthBuffer.mark = 0;
  SwigClassDepthBuffer.destroy = (void (*)(void *)) free_Ogre_DepthBuffer;
  SwigClassDepthBuffer.trackObjects = 0;
  
  SwigClassLodStrategy.klass = rb_define_class_under(mOgre, "LodStrategy", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LodStrategy, (void *) &SwigClassLodStrategy);
  rb_undef_alloc_func(SwigClassLodStrategy.klass);
  rb_define_method(SwigClassLodStrategy.klass, "getBaseValue", VALUEFUNC(_wrap_LodStrategy_getBaseValue), -1);
  rb_define_method(SwigClassLodStrategy.klass, "transformBias", VALUEFUNC(_wrap_LodStrategy_transformBias), -1);
  rb_define_method(SwigClassLodStrategy.klass, "transformUserValue", VALUEFUNC(_wrap_LodStrategy_transformUserValue), -1);
  rb_define_method(SwigClassLodStrategy.klass, "getValue", VALUEFUNC(_wrap_LodStrategy_getValue), -1);
  rb_define_method(SwigClassLodStrategy.klass, "getIndex", VALUEFUNC(_wrap_LodStrategy_getIndex), -1);
  rb_define_method(SwigClassLodStrategy.klass, "sort", VALUEFUNC(_wrap_LodStrategy_sort), -1);
  rb_define_method(SwigClassLodStrategy.klass, "isSorted", VALUEFUNC(_wrap_LodStrategy_isSorted), -1);
  rb_define_method(SwigClassLodStrategy.klass, "assertSorted", VALUEFUNC(_wrap_LodStrategy_assertSorted), -1);
  rb_define_method(SwigClassLodStrategy.klass, "getName", VALUEFUNC(_wrap_LodStrategy_getName), -1);
  SwigClassLodStrategy.mark = 0;
  SwigClassLodStrategy.destroy = (void (*)(void *)) free_Ogre_LodStrategy;
  SwigClassLodStrategy.trackObjects = 0;
  
  SwigClassDistanceLodStrategy.klass = rb_define_class_under(mOgre, "DistanceLodStrategy", ((swig_class *) SWIGTYPE_p_Ogre__LodStrategy->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DistanceLodStrategy, (void *) &SwigClassDistanceLodStrategy);
  rb_define_alloc_func(SwigClassDistanceLodStrategy.klass, _wrap_DistanceLodStrategy_allocate);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "initialize", VALUEFUNC(_wrap_new_DistanceLodStrategy), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "getBaseValue", VALUEFUNC(_wrap_DistanceLodStrategy_getBaseValue), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "transformBias", VALUEFUNC(_wrap_DistanceLodStrategy_transformBias), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "transformUserValue", VALUEFUNC(_wrap_DistanceLodStrategy_transformUserValue), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "getIndex", VALUEFUNC(_wrap_DistanceLodStrategy_getIndex), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "sort", VALUEFUNC(_wrap_DistanceLodStrategy_sort), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "isSorted", VALUEFUNC(_wrap_DistanceLodStrategy_isSorted), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "setReferenceView", VALUEFUNC(_wrap_DistanceLodStrategy_setReferenceView), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "setReferenceViewEnabled", VALUEFUNC(_wrap_DistanceLodStrategy_setReferenceViewEnabled), -1);
  rb_define_method(SwigClassDistanceLodStrategy.klass, "getReferenceViewEnabled", VALUEFUNC(_wrap_DistanceLodStrategy_getReferenceViewEnabled), -1);
  rb_define_singleton_method(SwigClassDistanceLodStrategy.klass, "getSingleton", VALUEFUNC(_wrap_DistanceLodStrategy_getSingleton), -1);
  rb_define_singleton_method(SwigClassDistanceLodStrategy.klass, "getSingletonPtr", VALUEFUNC(_wrap_DistanceLodStrategy_getSingletonPtr), -1);
  SwigClassDistanceLodStrategy.mark = 0;
  SwigClassDistanceLodStrategy.destroy = (void (*)(void *)) free_Ogre_DistanceLodStrategy;
  SwigClassDistanceLodStrategy.trackObjects = 0;
  
  SwigClassDualQuaternion.klass = rb_define_class_under(mOgre, "DualQuaternion", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DualQuaternion, (void *) &SwigClassDualQuaternion);
  rb_define_alloc_func(SwigClassDualQuaternion.klass, _wrap_DualQuaternion_allocate);
  rb_define_method(SwigClassDualQuaternion.klass, "initialize", VALUEFUNC(_wrap_new_DualQuaternion), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "==", VALUEFUNC(_wrap_DualQuaternion___eq__), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "ptr", VALUEFUNC(_wrap_DualQuaternion_ptr), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "swap", VALUEFUNC(_wrap_DualQuaternion_swap), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "isNaN", VALUEFUNC(_wrap_DualQuaternion_isNaN), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "fromRotationTranslation", VALUEFUNC(_wrap_DualQuaternion_fromRotationTranslation), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "toRotationTranslation", VALUEFUNC(_wrap_DualQuaternion_toRotationTranslation), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "fromTransformationMatrix", VALUEFUNC(_wrap_DualQuaternion_fromTransformationMatrix), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "toTransformationMatrix", VALUEFUNC(_wrap_DualQuaternion_toTransformationMatrix), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "w=", VALUEFUNC(_wrap_DualQuaternion_w_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "w", VALUEFUNC(_wrap_DualQuaternion_w_get), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "x=", VALUEFUNC(_wrap_DualQuaternion_x_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "x", VALUEFUNC(_wrap_DualQuaternion_x_get), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "y=", VALUEFUNC(_wrap_DualQuaternion_y_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "y", VALUEFUNC(_wrap_DualQuaternion_y_get), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "z=", VALUEFUNC(_wrap_DualQuaternion_z_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "z", VALUEFUNC(_wrap_DualQuaternion_z_get), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dw=", VALUEFUNC(_wrap_DualQuaternion_dw_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dw", VALUEFUNC(_wrap_DualQuaternion_dw_get), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dx=", VALUEFUNC(_wrap_DualQuaternion_dx_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dx", VALUEFUNC(_wrap_DualQuaternion_dx_get), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dy=", VALUEFUNC(_wrap_DualQuaternion_dy_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dy", VALUEFUNC(_wrap_DualQuaternion_dy_get), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dz=", VALUEFUNC(_wrap_DualQuaternion_dz_set), -1);
  rb_define_method(SwigClassDualQuaternion.klass, "dz", VALUEFUNC(_wrap_DualQuaternion_dz_get), -1);
  SwigClassDualQuaternion.mark = 0;
  SwigClassDualQuaternion.destroy = (void (*)(void *)) free_Ogre_DualQuaternion;
  SwigClassDualQuaternion.trackObjects = 0;
  
  SwigClassDynLib.klass = rb_define_class_under(mOgre, "DynLib", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DynLib, (void *) &SwigClassDynLib);
  rb_define_alloc_func(SwigClassDynLib.klass, _wrap_DynLib_allocate);
  rb_define_method(SwigClassDynLib.klass, "initialize", VALUEFUNC(_wrap_new_DynLib), -1);
  rb_define_method(SwigClassDynLib.klass, "load", VALUEFUNC(_wrap_DynLib_load), -1);
  rb_define_method(SwigClassDynLib.klass, "unload", VALUEFUNC(_wrap_DynLib_unload), -1);
  rb_define_method(SwigClassDynLib.klass, "getName", VALUEFUNC(_wrap_DynLib_getName), -1);
  rb_define_method(SwigClassDynLib.klass, "getSymbol", VALUEFUNC(_wrap_DynLib_getSymbol), -1);
  SwigClassDynLib.mark = 0;
  SwigClassDynLib.destroy = (void (*)(void *)) free_Ogre_DynLib;
  SwigClassDynLib.trackObjects = 0;
  
  SwigClassDynLibManager.klass = rb_define_class_under(mOgre, "DynLibManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DynLibManager, (void *) &SwigClassDynLibManager);
  rb_define_alloc_func(SwigClassDynLibManager.klass, _wrap_DynLibManager_allocate);
  rb_define_method(SwigClassDynLibManager.klass, "initialize", VALUEFUNC(_wrap_new_DynLibManager), -1);
  rb_define_method(SwigClassDynLibManager.klass, "load", VALUEFUNC(_wrap_DynLibManager_load), -1);
  rb_define_method(SwigClassDynLibManager.klass, "unload", VALUEFUNC(_wrap_DynLibManager_unload), -1);
  rb_define_singleton_method(SwigClassDynLibManager.klass, "getSingleton", VALUEFUNC(_wrap_DynLibManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassDynLibManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_DynLibManager_getSingletonPtr), -1);
  SwigClassDynLibManager.mark = 0;
  SwigClassDynLibManager.destroy = (void (*)(void *)) free_Ogre_DynLibManager;
  SwigClassDynLibManager.trackObjects = 0;
  
  SwigClassEdgeData.klass = rb_define_class_under(mOgre, "EdgeData", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EdgeData, (void *) &SwigClassEdgeData);
  rb_define_alloc_func(SwigClassEdgeData.klass, _wrap_EdgeData_allocate);
  rb_define_method(SwigClassEdgeData.klass, "initialize", VALUEFUNC(_wrap_new_EdgeData), -1);
  rb_define_method(SwigClassEdgeData.klass, "triangles=", VALUEFUNC(_wrap_EdgeData_triangles_set), -1);
  rb_define_method(SwigClassEdgeData.klass, "triangles", VALUEFUNC(_wrap_EdgeData_triangles_get), -1);
  rb_define_method(SwigClassEdgeData.klass, "triangleFaceNormals=", VALUEFUNC(_wrap_EdgeData_triangleFaceNormals_set), -1);
  rb_define_method(SwigClassEdgeData.klass, "triangleFaceNormals", VALUEFUNC(_wrap_EdgeData_triangleFaceNormals_get), -1);
  rb_define_method(SwigClassEdgeData.klass, "triangleLightFacings=", VALUEFUNC(_wrap_EdgeData_triangleLightFacings_set), -1);
  rb_define_method(SwigClassEdgeData.klass, "triangleLightFacings", VALUEFUNC(_wrap_EdgeData_triangleLightFacings_get), -1);
  rb_define_method(SwigClassEdgeData.klass, "edgeGroups=", VALUEFUNC(_wrap_EdgeData_edgeGroups_set), -1);
  rb_define_method(SwigClassEdgeData.klass, "edgeGroups", VALUEFUNC(_wrap_EdgeData_edgeGroups_get), -1);
  rb_define_method(SwigClassEdgeData.klass, "isClosed=", VALUEFUNC(_wrap_EdgeData_isClosed_set), -1);
  rb_define_method(SwigClassEdgeData.klass, "isClosed", VALUEFUNC(_wrap_EdgeData_isClosed_get), -1);
  rb_define_method(SwigClassEdgeData.klass, "updateTriangleLightFacing", VALUEFUNC(_wrap_EdgeData_updateTriangleLightFacing), -1);
  rb_define_method(SwigClassEdgeData.klass, "updateFaceNormals", VALUEFUNC(_wrap_EdgeData_updateFaceNormals), -1);
  rb_define_method(SwigClassEdgeData.klass, "log", VALUEFUNC(_wrap_EdgeData_log), -1);
  SwigClassEdgeData.mark = 0;
  SwigClassEdgeData.destroy = (void (*)(void *)) free_Ogre_EdgeData;
  SwigClassEdgeData.trackObjects = 0;
  
  SwigClassEdgeListBuilder.klass = rb_define_class_under(mOgre, "EdgeListBuilder", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EdgeListBuilder, (void *) &SwigClassEdgeListBuilder);
  rb_define_alloc_func(SwigClassEdgeListBuilder.klass, _wrap_EdgeListBuilder_allocate);
  rb_define_method(SwigClassEdgeListBuilder.klass, "initialize", VALUEFUNC(_wrap_new_EdgeListBuilder), -1);
  rb_define_method(SwigClassEdgeListBuilder.klass, "addVertexData", VALUEFUNC(_wrap_EdgeListBuilder_addVertexData), -1);
  rb_define_method(SwigClassEdgeListBuilder.klass, "addIndexData", VALUEFUNC(_wrap_EdgeListBuilder_addIndexData), -1);
  rb_define_method(SwigClassEdgeListBuilder.klass, "build", VALUEFUNC(_wrap_EdgeListBuilder_build), -1);
  rb_define_method(SwigClassEdgeListBuilder.klass, "log", VALUEFUNC(_wrap_EdgeListBuilder_log), -1);
  SwigClassEdgeListBuilder.mark = 0;
  SwigClassEdgeListBuilder.destroy = (void (*)(void *)) free_Ogre_EdgeListBuilder;
  SwigClassEdgeListBuilder.trackObjects = 0;
  
  SwigClassEntity.klass = rb_define_class_under(mOgre, "Entity", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Entity, (void *) &SwigClassEntity);
  rb_undef_alloc_func(SwigClassEntity.klass);
  rb_define_method(SwigClassEntity.klass, "getMesh", VALUEFUNC(_wrap_Entity_getMesh), -1);
  rb_define_method(SwigClassEntity.klass, "getSubEntity", VALUEFUNC(_wrap_Entity_getSubEntity), -1);
  rb_define_method(SwigClassEntity.klass, "getNumSubEntities", VALUEFUNC(_wrap_Entity_getNumSubEntities), -1);
  rb_define_method(SwigClassEntity.klass, "clone", VALUEFUNC(_wrap_Entity_clone), -1);
  rb_define_method(SwigClassEntity.klass, "setMaterialName", VALUEFUNC(_wrap_Entity_setMaterialName), -1);
  rb_define_method(SwigClassEntity.klass, "setMaterial", VALUEFUNC(_wrap_Entity_setMaterial), -1);
  rb_define_method(SwigClassEntity.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_Entity__notifyCurrentCamera), -1);
  rb_define_method(SwigClassEntity.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_Entity_setRenderQueueGroup), -1);
  rb_define_method(SwigClassEntity.klass, "setRenderQueueGroupAndPriority", VALUEFUNC(_wrap_Entity_setRenderQueueGroupAndPriority), -1);
  rb_define_method(SwigClassEntity.klass, "getBoundingBox", VALUEFUNC(_wrap_Entity_getBoundingBox), -1);
  rb_define_method(SwigClassEntity.klass, "getChildObjectsBoundingBox", VALUEFUNC(_wrap_Entity_getChildObjectsBoundingBox), -1);
  rb_define_method(SwigClassEntity.klass, "_updateRenderQueue", VALUEFUNC(_wrap_Entity__updateRenderQueue), -1);
  rb_define_method(SwigClassEntity.klass, "getMovableType", VALUEFUNC(_wrap_Entity_getMovableType), -1);
  rb_define_method(SwigClassEntity.klass, "getAnimationState", VALUEFUNC(_wrap_Entity_getAnimationState), -1);
  rb_define_method(SwigClassEntity.klass, "hasAnimationState", VALUEFUNC(_wrap_Entity_hasAnimationState), -1);
  rb_define_method(SwigClassEntity.klass, "getAllAnimationStates", VALUEFUNC(_wrap_Entity_getAllAnimationStates), -1);
  rb_define_method(SwigClassEntity.klass, "setDisplaySkeleton", VALUEFUNC(_wrap_Entity_setDisplaySkeleton), -1);
  rb_define_method(SwigClassEntity.klass, "getDisplaySkeleton", VALUEFUNC(_wrap_Entity_getDisplaySkeleton), -1);
  rb_define_method(SwigClassEntity.klass, "getManualLodLevel", VALUEFUNC(_wrap_Entity_getManualLodLevel), -1);
  rb_define_method(SwigClassEntity.klass, "getNumManualLodLevels", VALUEFUNC(_wrap_Entity_getNumManualLodLevels), -1);
  rb_define_method(SwigClassEntity.klass, "getCurrentLodIndex", VALUEFUNC(_wrap_Entity_getCurrentLodIndex), -1);
  rb_define_method(SwigClassEntity.klass, "setMeshLodBias", VALUEFUNC(_wrap_Entity_setMeshLodBias), -1);
  rb_define_method(SwigClassEntity.klass, "setMaterialLodBias", VALUEFUNC(_wrap_Entity_setMaterialLodBias), -1);
  rb_define_method(SwigClassEntity.klass, "setPolygonModeOverrideable", VALUEFUNC(_wrap_Entity_setPolygonModeOverrideable), -1);
  rb_define_method(SwigClassEntity.klass, "attachObjectToBone", VALUEFUNC(_wrap_Entity_attachObjectToBone), -1);
  rb_define_method(SwigClassEntity.klass, "detachObjectFromBone", VALUEFUNC(_wrap_Entity_detachObjectFromBone), -1);
  rb_define_method(SwigClassEntity.klass, "detachAllObjectsFromBone", VALUEFUNC(_wrap_Entity_detachAllObjectsFromBone), -1);
  rb_define_method(SwigClassEntity.klass, "getAttachedObjectIterator", VALUEFUNC(_wrap_Entity_getAttachedObjectIterator), -1);
  rb_define_method(SwigClassEntity.klass, "getBoundingRadius", VALUEFUNC(_wrap_Entity_getBoundingRadius), -1);
  rb_define_method(SwigClassEntity.klass, "getWorldBoundingBox", VALUEFUNC(_wrap_Entity_getWorldBoundingBox), -1);
  rb_define_method(SwigClassEntity.klass, "getWorldBoundingSphere", VALUEFUNC(_wrap_Entity_getWorldBoundingSphere), -1);
  rb_define_method(SwigClassEntity.klass, "getEdgeList", VALUEFUNC(_wrap_Entity_getEdgeList), -1);
  rb_define_method(SwigClassEntity.klass, "hasEdgeList", VALUEFUNC(_wrap_Entity_hasEdgeList), -1);
  rb_define_method(SwigClassEntity.klass, "getShadowVolumeRenderableIterator", VALUEFUNC(_wrap_Entity_getShadowVolumeRenderableIterator), -1);
  rb_define_method(SwigClassEntity.klass, "_getBoneMatrices", VALUEFUNC(_wrap_Entity__getBoneMatrices), -1);
  rb_define_method(SwigClassEntity.klass, "_getNumBoneMatrices", VALUEFUNC(_wrap_Entity__getNumBoneMatrices), -1);
  rb_define_method(SwigClassEntity.klass, "hasSkeleton", VALUEFUNC(_wrap_Entity_hasSkeleton), -1);
  rb_define_method(SwigClassEntity.klass, "getSkeleton", VALUEFUNC(_wrap_Entity_getSkeleton), -1);
  rb_define_method(SwigClassEntity.klass, "isHardwareAnimationEnabled", VALUEFUNC(_wrap_Entity_isHardwareAnimationEnabled), -1);
  rb_define_method(SwigClassEntity.klass, "_notifyAttached", VALUEFUNC(_wrap_Entity__notifyAttached), -1);
  rb_define_method(SwigClassEntity.klass, "getSoftwareAnimationRequests", VALUEFUNC(_wrap_Entity_getSoftwareAnimationRequests), -1);
  rb_define_method(SwigClassEntity.klass, "getSoftwareAnimationNormalsRequests", VALUEFUNC(_wrap_Entity_getSoftwareAnimationNormalsRequests), -1);
  rb_define_method(SwigClassEntity.klass, "addSoftwareAnimationRequest", VALUEFUNC(_wrap_Entity_addSoftwareAnimationRequest), -1);
  rb_define_method(SwigClassEntity.klass, "removeSoftwareAnimationRequest", VALUEFUNC(_wrap_Entity_removeSoftwareAnimationRequest), -1);
  rb_define_method(SwigClassEntity.klass, "shareSkeletonInstanceWith", VALUEFUNC(_wrap_Entity_shareSkeletonInstanceWith), -1);
  rb_define_method(SwigClassEntity.klass, "hasVertexAnimation", VALUEFUNC(_wrap_Entity_hasVertexAnimation), -1);
  rb_define_method(SwigClassEntity.klass, "stopSharingSkeletonInstance", VALUEFUNC(_wrap_Entity_stopSharingSkeletonInstance), -1);
  rb_define_method(SwigClassEntity.klass, "sharesSkeletonInstance", VALUEFUNC(_wrap_Entity_sharesSkeletonInstance), -1);
  rb_define_method(SwigClassEntity.klass, "getSkeletonInstanceSharingSet", VALUEFUNC(_wrap_Entity_getSkeletonInstanceSharingSet), -1);
  rb_define_method(SwigClassEntity.klass, "refreshAvailableAnimationState", VALUEFUNC(_wrap_Entity_refreshAvailableAnimationState), -1);
  rb_define_method(SwigClassEntity.klass, "_updateAnimation", VALUEFUNC(_wrap_Entity__updateAnimation), -1);
  rb_define_method(SwigClassEntity.klass, "_isAnimated", VALUEFUNC(_wrap_Entity__isAnimated), -1);
  rb_define_method(SwigClassEntity.klass, "_isSkeletonAnimated", VALUEFUNC(_wrap_Entity__isSkeletonAnimated), -1);
  rb_define_method(SwigClassEntity.klass, "_getSkelAnimVertexData", VALUEFUNC(_wrap_Entity__getSkelAnimVertexData), -1);
  rb_define_method(SwigClassEntity.klass, "_getSoftwareVertexAnimVertexData", VALUEFUNC(_wrap_Entity__getSoftwareVertexAnimVertexData), -1);
  rb_define_method(SwigClassEntity.klass, "_getHardwareVertexAnimVertexData", VALUEFUNC(_wrap_Entity__getHardwareVertexAnimVertexData), -1);
  rb_define_method(SwigClassEntity.klass, "_getSkelAnimTempBufferInfo", VALUEFUNC(_wrap_Entity__getSkelAnimTempBufferInfo), -1);
  rb_define_method(SwigClassEntity.klass, "_getVertexAnimTempBufferInfo", VALUEFUNC(_wrap_Entity__getVertexAnimTempBufferInfo), -1);
  rb_define_method(SwigClassEntity.klass, "getTypeFlags", VALUEFUNC(_wrap_Entity_getTypeFlags), -1);
  rb_define_method(SwigClassEntity.klass, "getVertexDataForBinding", VALUEFUNC(_wrap_Entity_getVertexDataForBinding), -1);
  rb_define_const(SwigClassEntity.klass, "BIND_ORIGINAL", SWIG_From_int(static_cast< int >(Ogre::Entity::BIND_ORIGINAL)));
  rb_define_const(SwigClassEntity.klass, "BIND_SOFTWARE_SKELETAL", SWIG_From_int(static_cast< int >(Ogre::Entity::BIND_SOFTWARE_SKELETAL)));
  rb_define_const(SwigClassEntity.klass, "BIND_SOFTWARE_MORPH", SWIG_From_int(static_cast< int >(Ogre::Entity::BIND_SOFTWARE_MORPH)));
  rb_define_const(SwigClassEntity.klass, "BIND_HARDWARE_MORPH", SWIG_From_int(static_cast< int >(Ogre::Entity::BIND_HARDWARE_MORPH)));
  rb_define_method(SwigClassEntity.klass, "chooseVertexDataForBinding", VALUEFUNC(_wrap_Entity_chooseVertexDataForBinding), -1);
  rb_define_method(SwigClassEntity.klass, "_getBuffersMarkedForAnimation", VALUEFUNC(_wrap_Entity__getBuffersMarkedForAnimation), -1);
  rb_define_method(SwigClassEntity.klass, "_markBuffersUsedForAnimation", VALUEFUNC(_wrap_Entity__markBuffersUsedForAnimation), -1);
  rb_define_method(SwigClassEntity.klass, "isInitialised", VALUEFUNC(_wrap_Entity_isInitialised), -1);
  rb_define_method(SwigClassEntity.klass, "_initialise", VALUEFUNC(_wrap_Entity__initialise), -1);
  rb_define_method(SwigClassEntity.klass, "_deinitialise", VALUEFUNC(_wrap_Entity__deinitialise), -1);
  rb_define_method(SwigClassEntity.klass, "backgroundLoadingComplete", VALUEFUNC(_wrap_Entity_backgroundLoadingComplete), -1);
  rb_define_method(SwigClassEntity.klass, "visitRenderables", VALUEFUNC(_wrap_Entity_visitRenderables), -1);
  rb_define_method(SwigClassEntity.klass, "_getMeshLodFactorTransformed", VALUEFUNC(_wrap_Entity__getMeshLodFactorTransformed), -1);
  rb_define_method(SwigClassEntity.klass, "setSkipAnimationStateUpdate", VALUEFUNC(_wrap_Entity_setSkipAnimationStateUpdate), -1);
  rb_define_method(SwigClassEntity.klass, "getSkipAnimationStateUpdate", VALUEFUNC(_wrap_Entity_getSkipAnimationStateUpdate), -1);
  rb_define_method(SwigClassEntity.klass, "setAlwaysUpdateMainSkeleton", VALUEFUNC(_wrap_Entity_setAlwaysUpdateMainSkeleton), -1);
  rb_define_method(SwigClassEntity.klass, "getAlwaysUpdateMainSkeleton", VALUEFUNC(_wrap_Entity_getAlwaysUpdateMainSkeleton), -1);
  SwigClassEntity.mark = 0;
  SwigClassEntity.destroy = (void (*)(void *)) free_Ogre_Entity;
  SwigClassEntity.trackObjects = 0;
  
  SwigClassEntityFactory.klass = rb_define_class_under(mOgre, "EntityFactory", ((swig_class *) SWIGTYPE_p_Ogre__MovableObjectFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EntityFactory, (void *) &SwigClassEntityFactory);
  rb_undef_alloc_func(SwigClassEntityFactory.klass);
  rb_define_singleton_method(SwigClassEntityFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_EntityFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_singleton_method(SwigClassEntityFactory.klass, "FACTORY_TYPE_NAME=", VALUEFUNC(_wrap_EntityFactory_FACTORY_TYPE_NAME_set), 1);
  rb_define_method(SwigClassEntityFactory.klass, "getType", VALUEFUNC(_wrap_EntityFactory_getType), -1);
  rb_define_method(SwigClassEntityFactory.klass, "destroyInstance", VALUEFUNC(_wrap_EntityFactory_destroyInstance), -1);
  SwigClassEntityFactory.mark = 0;
  SwigClassEntityFactory.destroy = (void (*)(void *)) free_Ogre_EntityFactory;
  SwigClassEntityFactory.trackObjects = 0;
  rb_define_const(mOgre, "TextureEffectPause", SWIG_From_int(static_cast< int >(Ogre::TextureEffectPause)));
  rb_define_const(mOgre, "TextureEffectPlay_ASAP", SWIG_From_int(static_cast< int >(Ogre::TextureEffectPlay_ASAP)));
  rb_define_const(mOgre, "TextureEffectPlay_Looping", SWIG_From_int(static_cast< int >(Ogre::TextureEffectPlay_Looping)));
  
  SwigClassExternalTextureSource.klass = rb_define_class_under(mOgre, "ExternalTextureSource", ((swig_class *) SWIGTYPE_p_Ogre__StringInterface->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ExternalTextureSource, (void *) &SwigClassExternalTextureSource);
  rb_undef_alloc_func(SwigClassExternalTextureSource.klass);
  rb_define_method(SwigClassExternalTextureSource.klass, "setInputName", VALUEFUNC(_wrap_ExternalTextureSource_setInputName), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "getInputName", VALUEFUNC(_wrap_ExternalTextureSource_getInputName), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "setFPS", VALUEFUNC(_wrap_ExternalTextureSource_setFPS), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "getFPS", VALUEFUNC(_wrap_ExternalTextureSource_getFPS), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "setPlayMode", VALUEFUNC(_wrap_ExternalTextureSource_setPlayMode), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "getPlayMode", VALUEFUNC(_wrap_ExternalTextureSource_getPlayMode), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "setTextureTecPassStateLevel", VALUEFUNC(_wrap_ExternalTextureSource_setTextureTecPassStateLevel), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "getTextureTecPassStateLevel", VALUEFUNC(_wrap_ExternalTextureSource_getTextureTecPassStateLevel), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "addBaseParams", VALUEFUNC(_wrap_ExternalTextureSource_addBaseParams), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "getPluginStringName", VALUEFUNC(_wrap_ExternalTextureSource_getPluginStringName), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "getDictionaryStringName", VALUEFUNC(_wrap_ExternalTextureSource_getDictionaryStringName), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "initialise", VALUEFUNC(_wrap_ExternalTextureSource_initialise), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "shutDown", VALUEFUNC(_wrap_ExternalTextureSource_shutDown), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "createDefinedTexture", VALUEFUNC(_wrap_ExternalTextureSource_createDefinedTexture), -1);
  rb_define_method(SwigClassExternalTextureSource.klass, "destroyAdvancedTexture", VALUEFUNC(_wrap_ExternalTextureSource_destroyAdvancedTexture), -1);
  SwigClassExternalTextureSource.mark = 0;
  SwigClassExternalTextureSource.destroy = (void (*)(void *)) free_Ogre_ExternalTextureSource;
  SwigClassExternalTextureSource.trackObjects = 0;
  
  SwigClassExternalTextureSourceManager.klass = rb_define_class_under(mOgre, "ExternalTextureSourceManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ExternalTextureSourceManager, (void *) &SwigClassExternalTextureSourceManager);
  rb_define_alloc_func(SwigClassExternalTextureSourceManager.klass, _wrap_ExternalTextureSourceManager_allocate);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "initialize", VALUEFUNC(_wrap_new_ExternalTextureSourceManager), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "setCurrentPlugIn", VALUEFUNC(_wrap_ExternalTextureSourceManager_setCurrentPlugIn), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "getCurrentPlugIn", VALUEFUNC(_wrap_ExternalTextureSourceManager_getCurrentPlugIn), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "destroyAdvancedTexture", VALUEFUNC(_wrap_ExternalTextureSourceManager_destroyAdvancedTexture), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "getExternalTextureSource", VALUEFUNC(_wrap_ExternalTextureSourceManager_getExternalTextureSource), -1);
  rb_define_method(SwigClassExternalTextureSourceManager.klass, "setExternalTextureSource", VALUEFUNC(_wrap_ExternalTextureSourceManager_setExternalTextureSource), -1);
  rb_define_singleton_method(SwigClassExternalTextureSourceManager.klass, "getSingleton", VALUEFUNC(_wrap_ExternalTextureSourceManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassExternalTextureSourceManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_ExternalTextureSourceManager_getSingletonPtr), -1);
  SwigClassExternalTextureSourceManager.mark = 0;
  SwigClassExternalTextureSourceManager.destroy = (void (*)(void *)) free_Ogre_ExternalTextureSourceManager;
  SwigClassExternalTextureSourceManager.trackObjects = 0;
  
  SwigClassFileSystemArchive.klass = rb_define_class_under(mOgre, "FileSystemArchive", ((swig_class *) SWIGTYPE_p_Ogre__Archive->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FileSystemArchive, (void *) &SwigClassFileSystemArchive);
  rb_define_alloc_func(SwigClassFileSystemArchive.klass, _wrap_FileSystemArchive_allocate);
  rb_define_method(SwigClassFileSystemArchive.klass, "initialize", VALUEFUNC(_wrap_new_FileSystemArchive), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "isCaseSensitive", VALUEFUNC(_wrap_FileSystemArchive_isCaseSensitive), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "load", VALUEFUNC(_wrap_FileSystemArchive_load), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "unload", VALUEFUNC(_wrap_FileSystemArchive_unload), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "open", VALUEFUNC(_wrap_FileSystemArchive_open), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "create", VALUEFUNC(_wrap_FileSystemArchive_create), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "remove", VALUEFUNC(_wrap_FileSystemArchive_remove), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "list", VALUEFUNC(_wrap_FileSystemArchive_list), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "listFileInfo", VALUEFUNC(_wrap_FileSystemArchive_listFileInfo), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "find", VALUEFUNC(_wrap_FileSystemArchive_find), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "findFileInfo", VALUEFUNC(_wrap_FileSystemArchive_findFileInfo), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "exists", VALUEFUNC(_wrap_FileSystemArchive_exists), -1);
  rb_define_method(SwigClassFileSystemArchive.klass, "getModifiedTime", VALUEFUNC(_wrap_FileSystemArchive_getModifiedTime), -1);
  rb_define_singleton_method(SwigClassFileSystemArchive.klass, "setIgnoreHidden", VALUEFUNC(_wrap_FileSystemArchive_setIgnoreHidden), -1);
  rb_define_singleton_method(SwigClassFileSystemArchive.klass, "getIgnoreHidden", VALUEFUNC(_wrap_FileSystemArchive_getIgnoreHidden), -1);
  rb_define_singleton_method(SwigClassFileSystemArchive.klass, "msIgnoreHidden", VALUEFUNC(_wrap_FileSystemArchive_msIgnoreHidden_get), 0);
  rb_define_singleton_method(SwigClassFileSystemArchive.klass, "msIgnoreHidden=", VALUEFUNC(_wrap_FileSystemArchive_msIgnoreHidden_set), 1);
  SwigClassFileSystemArchive.mark = 0;
  SwigClassFileSystemArchive.destroy = (void (*)(void *)) free_Ogre_FileSystemArchive;
  SwigClassFileSystemArchive.trackObjects = 0;
  
  SwigClassFileSystemArchiveFactory.klass = rb_define_class_under(mOgre, "FileSystemArchiveFactory", ((swig_class *) SWIGTYPE_p_Ogre__ArchiveFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FileSystemArchiveFactory, (void *) &SwigClassFileSystemArchiveFactory);
  rb_define_alloc_func(SwigClassFileSystemArchiveFactory.klass, _wrap_FileSystemArchiveFactory_allocate);
  rb_define_method(SwigClassFileSystemArchiveFactory.klass, "initialize", VALUEFUNC(_wrap_new_FileSystemArchiveFactory), -1);
  rb_define_method(SwigClassFileSystemArchiveFactory.klass, "getType", VALUEFUNC(_wrap_FileSystemArchiveFactory_getType), -1);
  rb_define_method(SwigClassFileSystemArchiveFactory.klass, "createInstance", VALUEFUNC(_wrap_FileSystemArchiveFactory_createInstance), -1);
  rb_define_method(SwigClassFileSystemArchiveFactory.klass, "destroyInstance", VALUEFUNC(_wrap_FileSystemArchiveFactory_destroyInstance), -1);
  SwigClassFileSystemArchiveFactory.mark = 0;
  SwigClassFileSystemArchiveFactory.destroy = (void (*)(void *)) free_Ogre_FileSystemArchiveFactory;
  SwigClassFileSystemArchiveFactory.trackObjects = 0;
  rb_define_const(mOgre, "FT_TRUETYPE", SWIG_From_int(static_cast< int >(Ogre::FT_TRUETYPE)));
  rb_define_const(mOgre, "FT_IMAGE", SWIG_From_int(static_cast< int >(Ogre::FT_IMAGE)));
  
  SwigClassFont.klass = rb_define_class_under(mOgre, "Font", ((swig_class *) SWIGTYPE_p_Ogre__Resource->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Font, (void *) &SwigClassFont);
  rb_define_alloc_func(SwigClassFont.klass, _wrap_Font_allocate);
  rb_define_method(SwigClassFont.klass, "initialize", VALUEFUNC(_wrap_new_Font), -1);
  rb_define_method(SwigClassFont.klass, "setType", VALUEFUNC(_wrap_Font_setType), -1);
  rb_define_method(SwigClassFont.klass, "getType", VALUEFUNC(_wrap_Font_getType), -1);
  rb_define_method(SwigClassFont.klass, "setSource", VALUEFUNC(_wrap_Font_setSource), -1);
  rb_define_method(SwigClassFont.klass, "getSource", VALUEFUNC(_wrap_Font_getSource), -1);
  rb_define_method(SwigClassFont.klass, "setCharacterSpacer", VALUEFUNC(_wrap_Font_setCharacterSpacer), -1);
  rb_define_method(SwigClassFont.klass, "getCharacterSpacer", VALUEFUNC(_wrap_Font_getCharacterSpacer), -1);
  rb_define_method(SwigClassFont.klass, "setTrueTypeSize", VALUEFUNC(_wrap_Font_setTrueTypeSize), -1);
  rb_define_method(SwigClassFont.klass, "setTrueTypeResolution", VALUEFUNC(_wrap_Font_setTrueTypeResolution), -1);
  rb_define_method(SwigClassFont.klass, "getTrueTypeSize", VALUEFUNC(_wrap_Font_getTrueTypeSize), -1);
  rb_define_method(SwigClassFont.klass, "getTrueTypeResolution", VALUEFUNC(_wrap_Font_getTrueTypeResolution), -1);
  rb_define_method(SwigClassFont.klass, "getTrueTypeMaxBearingY", VALUEFUNC(_wrap_Font_getTrueTypeMaxBearingY), -1);
  rb_define_method(SwigClassFont.klass, "getGlyphTexCoords", VALUEFUNC(_wrap_Font_getGlyphTexCoords), -1);
  rb_define_method(SwigClassFont.klass, "setGlyphTexCoords", VALUEFUNC(_wrap_Font_setGlyphTexCoords), -1);
  rb_define_method(SwigClassFont.klass, "getGlyphAspectRatio", VALUEFUNC(_wrap_Font_getGlyphAspectRatio), -1);
  rb_define_method(SwigClassFont.klass, "setGlyphAspectRatio", VALUEFUNC(_wrap_Font_setGlyphAspectRatio), -1);
  rb_define_method(SwigClassFont.klass, "getGlyphInfo", VALUEFUNC(_wrap_Font_getGlyphInfo), -1);
  rb_define_method(SwigClassFont.klass, "addCodePointRange", VALUEFUNC(_wrap_Font_addCodePointRange), -1);
  rb_define_method(SwigClassFont.klass, "clearCodePointRanges", VALUEFUNC(_wrap_Font_clearCodePointRanges), -1);
  rb_define_method(SwigClassFont.klass, "getCodePointRangeList", VALUEFUNC(_wrap_Font_getCodePointRangeList), -1);
  rb_define_method(SwigClassFont.klass, "getMaterial", VALUEFUNC(_wrap_Font_getMaterial), -1);
  rb_define_method(SwigClassFont.klass, "setAntialiasColour", VALUEFUNC(_wrap_Font_setAntialiasColour), -1);
  rb_define_method(SwigClassFont.klass, "getAntialiasColour", VALUEFUNC(_wrap_Font_getAntialiasColour), -1);
  rb_define_method(SwigClassFont.klass, "loadResource", VALUEFUNC(_wrap_Font_loadResource), -1);
  SwigClassFont.mark = 0;
  SwigClassFont.destroy = (void (*)(void *)) free_Ogre_Font;
  SwigClassFont.trackObjects = 0;
  
  SwigClassFontPtr.klass = rb_define_class_under(mOgre, "FontPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FontPtr, (void *) &SwigClassFontPtr);
  rb_define_alloc_func(SwigClassFontPtr.klass, _wrap_FontPtr_allocate);
  rb_define_method(SwigClassFontPtr.klass, "initialize", VALUEFUNC(_wrap_new_FontPtr), -1);
  SwigClassFontPtr.mark = 0;
  SwigClassFontPtr.destroy = (void (*)(void *)) free_Ogre_FontPtr;
  SwigClassFontPtr.trackObjects = 0;
  
  SwigClassFontManager.klass = rb_define_class_under(mOgre, "FontManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FontManager, (void *) &SwigClassFontManager);
  rb_define_alloc_func(SwigClassFontManager.klass, _wrap_FontManager_allocate);
  rb_define_method(SwigClassFontManager.klass, "initialize", VALUEFUNC(_wrap_new_FontManager), -1);
  rb_define_method(SwigClassFontManager.klass, "parseScript", VALUEFUNC(_wrap_FontManager_parseScript), -1);
  rb_define_singleton_method(SwigClassFontManager.klass, "getSingleton", VALUEFUNC(_wrap_FontManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassFontManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_FontManager_getSingletonPtr), -1);
  SwigClassFontManager.mark = 0;
  SwigClassFontManager.destroy = (void (*)(void *)) free_Ogre_FontManager;
  SwigClassFontManager.trackObjects = 0;
  
  SwigClassFreeImageCodec.klass = rb_define_class_under(mOgre, "FreeImageCodec", ((swig_class *) SWIGTYPE_p_Ogre__ImageCodec->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FreeImageCodec, (void *) &SwigClassFreeImageCodec);
  rb_define_alloc_func(SwigClassFreeImageCodec.klass, _wrap_FreeImageCodec_allocate);
  rb_define_method(SwigClassFreeImageCodec.klass, "initialize", VALUEFUNC(_wrap_new_FreeImageCodec), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "code", VALUEFUNC(_wrap_FreeImageCodec_code), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "codeToFile", VALUEFUNC(_wrap_FreeImageCodec_codeToFile), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "decode", VALUEFUNC(_wrap_FreeImageCodec_decode), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "getType", VALUEFUNC(_wrap_FreeImageCodec_getType), -1);
  rb_define_method(SwigClassFreeImageCodec.klass, "magicNumberToFileExt", VALUEFUNC(_wrap_FreeImageCodec_magicNumberToFileExt), -1);
  rb_define_singleton_method(SwigClassFreeImageCodec.klass, "startup", VALUEFUNC(_wrap_FreeImageCodec_startup), -1);
  rb_define_singleton_method(SwigClassFreeImageCodec.klass, "shutdown", VALUEFUNC(_wrap_FreeImageCodec_shutdown), -1);
  SwigClassFreeImageCodec.mark = 0;
  SwigClassFreeImageCodec.destroy = (void (*)(void *)) free_Ogre_FreeImageCodec;
  SwigClassFreeImageCodec.trackObjects = 0;
  
  SwigClassGpuProgramManager.klass = rb_define_class_under(mOgre, "GpuProgramManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuProgramManager, (void *) &SwigClassGpuProgramManager);
  rb_undef_alloc_func(SwigClassGpuProgramManager.klass);
  rb_define_method(SwigClassGpuProgramManager.klass, "load", VALUEFUNC(_wrap_GpuProgramManager_load), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "loadFromString", VALUEFUNC(_wrap_GpuProgramManager_loadFromString), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "getSupportedSyntax", VALUEFUNC(_wrap_GpuProgramManager_getSupportedSyntax), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "isSyntaxSupported", VALUEFUNC(_wrap_GpuProgramManager_isSyntaxSupported), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "createParameters", VALUEFUNC(_wrap_GpuProgramManager_createParameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "createProgram", VALUEFUNC(_wrap_GpuProgramManager_createProgram), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "createProgramFromString", VALUEFUNC(_wrap_GpuProgramManager_createProgramFromString), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "create", VALUEFUNC(_wrap_GpuProgramManager_create), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "getByName", VALUEFUNC(_wrap_GpuProgramManager_getByName), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "createSharedParameters", VALUEFUNC(_wrap_GpuProgramManager_createSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "getSharedParameters", VALUEFUNC(_wrap_GpuProgramManager_getSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "getAvailableSharedParameters", VALUEFUNC(_wrap_GpuProgramManager_getAvailableSharedParameters), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "getSaveMicrocodesToCache", VALUEFUNC(_wrap_GpuProgramManager_getSaveMicrocodesToCache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "setSaveMicrocodesToCache", VALUEFUNC(_wrap_GpuProgramManager_setSaveMicrocodesToCache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "canGetCompiledShaderBuffer", VALUEFUNC(_wrap_GpuProgramManager_canGetCompiledShaderBuffer), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "isMicrocodeAvailableInCache", VALUEFUNC(_wrap_GpuProgramManager_isMicrocodeAvailableInCache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "getMicrocodeFromCache", VALUEFUNC(_wrap_GpuProgramManager_getMicrocodeFromCache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "createMicrocode", VALUEFUNC(_wrap_GpuProgramManager_createMicrocode), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "addMicrocodeToCache", VALUEFUNC(_wrap_GpuProgramManager_addMicrocodeToCache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "saveMicrocodeCache", VALUEFUNC(_wrap_GpuProgramManager_saveMicrocodeCache), -1);
  rb_define_method(SwigClassGpuProgramManager.klass, "loadMicrocodeCache", VALUEFUNC(_wrap_GpuProgramManager_loadMicrocodeCache), -1);
  rb_define_singleton_method(SwigClassGpuProgramManager.klass, "getSingleton", VALUEFUNC(_wrap_GpuProgramManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassGpuProgramManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_GpuProgramManager_getSingletonPtr), -1);
  SwigClassGpuProgramManager.mark = 0;
  SwigClassGpuProgramManager.destroy = (void (*)(void *)) free_Ogre_GpuProgramManager;
  SwigClassGpuProgramManager.trackObjects = 0;
  
  SwigClassGpuProgramUsage.klass = rb_define_class_under(mOgre, "GpuProgramUsage", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuProgramUsage, (void *) &SwigClassGpuProgramUsage);
  rb_define_alloc_func(SwigClassGpuProgramUsage.klass, _wrap_GpuProgramUsage_allocate);
  rb_define_method(SwigClassGpuProgramUsage.klass, "initialize", VALUEFUNC(_wrap_new_GpuProgramUsage), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "getType", VALUEFUNC(_wrap_GpuProgramUsage_getType), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "setProgramName", VALUEFUNC(_wrap_GpuProgramUsage_setProgramName), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "setProgram", VALUEFUNC(_wrap_GpuProgramUsage_setProgram), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "getProgram", VALUEFUNC(_wrap_GpuProgramUsage_getProgram), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "getProgramName", VALUEFUNC(_wrap_GpuProgramUsage_getProgramName), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "setParameters", VALUEFUNC(_wrap_GpuProgramUsage_setParameters), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "getParameters", VALUEFUNC(_wrap_GpuProgramUsage_getParameters), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "_load", VALUEFUNC(_wrap_GpuProgramUsage__load), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "_unload", VALUEFUNC(_wrap_GpuProgramUsage__unload), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "unloadingComplete", VALUEFUNC(_wrap_GpuProgramUsage_unloadingComplete), -1);
  rb_define_method(SwigClassGpuProgramUsage.klass, "loadingComplete", VALUEFUNC(_wrap_GpuProgramUsage_loadingComplete), -1);
  SwigClassGpuProgramUsage.mark = 0;
  SwigClassGpuProgramUsage.destroy = (void (*)(void *)) free_Ogre_GpuProgramUsage;
  SwigClassGpuProgramUsage.trackObjects = 0;
  
  SwigClassHardwareOcclusionQuery.klass = rb_define_class_under(mOgre, "HardwareOcclusionQuery", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwareOcclusionQuery, (void *) &SwigClassHardwareOcclusionQuery);
  rb_undef_alloc_func(SwigClassHardwareOcclusionQuery.klass);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "beginOcclusionQuery", VALUEFUNC(_wrap_HardwareOcclusionQuery_beginOcclusionQuery), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "endOcclusionQuery", VALUEFUNC(_wrap_HardwareOcclusionQuery_endOcclusionQuery), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "pullOcclusionQuery", VALUEFUNC(_wrap_HardwareOcclusionQuery_pullOcclusionQuery), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "getLastQuerysPixelcount", VALUEFUNC(_wrap_HardwareOcclusionQuery_getLastQuerysPixelcount), -1);
  rb_define_method(SwigClassHardwareOcclusionQuery.klass, "isStillOutstanding", VALUEFUNC(_wrap_HardwareOcclusionQuery_isStillOutstanding), -1);
  SwigClassHardwareOcclusionQuery.mark = 0;
  SwigClassHardwareOcclusionQuery.destroy = (void (*)(void *)) free_Ogre_HardwareOcclusionQuery;
  SwigClassHardwareOcclusionQuery.trackObjects = 0;
  
  SwigClassHardwarePixelBuffer.klass = rb_define_class_under(mOgre, "HardwarePixelBuffer", ((swig_class *) SWIGTYPE_p_Ogre__HardwareBuffer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwarePixelBuffer, (void *) &SwigClassHardwarePixelBuffer);
  rb_undef_alloc_func(SwigClassHardwarePixelBuffer.klass);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "lock", VALUEFUNC(_wrap_HardwarePixelBuffer_lock), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "getCurrentLock", VALUEFUNC(_wrap_HardwarePixelBuffer_getCurrentLock), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "readData", VALUEFUNC(_wrap_HardwarePixelBuffer_readData), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "writeData", VALUEFUNC(_wrap_HardwarePixelBuffer_writeData), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "blit", VALUEFUNC(_wrap_HardwarePixelBuffer_blit), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "blitFromMemory", VALUEFUNC(_wrap_HardwarePixelBuffer_blitFromMemory), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "blitToMemory", VALUEFUNC(_wrap_HardwarePixelBuffer_blitToMemory), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "getRenderTarget", VALUEFUNC(_wrap_HardwarePixelBuffer_getRenderTarget), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "getWidth", VALUEFUNC(_wrap_HardwarePixelBuffer_getWidth), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "getHeight", VALUEFUNC(_wrap_HardwarePixelBuffer_getHeight), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "getDepth", VALUEFUNC(_wrap_HardwarePixelBuffer_getDepth), -1);
  rb_define_method(SwigClassHardwarePixelBuffer.klass, "getFormat", VALUEFUNC(_wrap_HardwarePixelBuffer_getFormat), -1);
  SwigClassHardwarePixelBuffer.mark = 0;
  SwigClassHardwarePixelBuffer.destroy = (void (*)(void *)) free_Ogre_HardwarePixelBuffer;
  SwigClassHardwarePixelBuffer.trackObjects = 0;
  
  SwigClassHardwarePixelBufferSharedPtr.klass = rb_define_class_under(mOgre, "HardwarePixelBufferSharedPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HardwarePixelBufferSharedPtr, (void *) &SwigClassHardwarePixelBufferSharedPtr);
  rb_define_alloc_func(SwigClassHardwarePixelBufferSharedPtr.klass, _wrap_HardwarePixelBufferSharedPtr_allocate);
  rb_define_method(SwigClassHardwarePixelBufferSharedPtr.klass, "initialize", VALUEFUNC(_wrap_new_HardwarePixelBufferSharedPtr), -1);
  SwigClassHardwarePixelBufferSharedPtr.mark = 0;
  SwigClassHardwarePixelBufferSharedPtr.destroy = (void (*)(void *)) free_Ogre_HardwarePixelBufferSharedPtr;
  SwigClassHardwarePixelBufferSharedPtr.trackObjects = 0;
  
  SwigClassHighLevelGpuProgram.klass = rb_define_class_under(mOgre, "HighLevelGpuProgram", ((swig_class *) SWIGTYPE_p_Ogre__GpuProgram->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HighLevelGpuProgram, (void *) &SwigClassHighLevelGpuProgram);
  rb_undef_alloc_func(SwigClassHighLevelGpuProgram.klass);
  rb_define_method(SwigClassHighLevelGpuProgram.klass, "createParameters", VALUEFUNC(_wrap_HighLevelGpuProgram_createParameters), -1);
  rb_define_method(SwigClassHighLevelGpuProgram.klass, "_getBindingDelegate", VALUEFUNC(_wrap_HighLevelGpuProgram__getBindingDelegate), -1);
  rb_define_method(SwigClassHighLevelGpuProgram.klass, "getConstantDefinitions", VALUEFUNC(_wrap_HighLevelGpuProgram_getConstantDefinitions), -1);
  rb_define_method(SwigClassHighLevelGpuProgram.klass, "getNamedConstants", VALUEFUNC(_wrap_HighLevelGpuProgram_getNamedConstants), -1);
  SwigClassHighLevelGpuProgram.mark = 0;
  SwigClassHighLevelGpuProgram.destroy = (void (*)(void *)) free_Ogre_HighLevelGpuProgram;
  SwigClassHighLevelGpuProgram.trackObjects = 0;
  
  SwigClassHighLevelGpuProgramPtr.klass = rb_define_class_under(mOgre, "HighLevelGpuProgramPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HighLevelGpuProgramPtr, (void *) &SwigClassHighLevelGpuProgramPtr);
  rb_define_alloc_func(SwigClassHighLevelGpuProgramPtr.klass, _wrap_HighLevelGpuProgramPtr_allocate);
  rb_define_method(SwigClassHighLevelGpuProgramPtr.klass, "initialize", VALUEFUNC(_wrap_new_HighLevelGpuProgramPtr), -1);
  SwigClassHighLevelGpuProgramPtr.mark = 0;
  SwigClassHighLevelGpuProgramPtr.destroy = (void (*)(void *)) free_Ogre_HighLevelGpuProgramPtr;
  SwigClassHighLevelGpuProgramPtr.trackObjects = 0;
  
  SwigClassHighLevelGpuProgramFactory.klass = rb_define_class_under(mOgre, "HighLevelGpuProgramFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HighLevelGpuProgramFactory, (void *) &SwigClassHighLevelGpuProgramFactory);
  rb_undef_alloc_func(SwigClassHighLevelGpuProgramFactory.klass);
  rb_define_method(SwigClassHighLevelGpuProgramFactory.klass, "getLanguage", VALUEFUNC(_wrap_HighLevelGpuProgramFactory_getLanguage), -1);
  rb_define_method(SwigClassHighLevelGpuProgramFactory.klass, "create", VALUEFUNC(_wrap_HighLevelGpuProgramFactory_create), -1);
  rb_define_method(SwigClassHighLevelGpuProgramFactory.klass, "destroy", VALUEFUNC(_wrap_HighLevelGpuProgramFactory_destroy), -1);
  SwigClassHighLevelGpuProgramFactory.mark = 0;
  SwigClassHighLevelGpuProgramFactory.destroy = (void (*)(void *)) free_Ogre_HighLevelGpuProgramFactory;
  SwigClassHighLevelGpuProgramFactory.trackObjects = 0;
  
  SwigClassHighLevelGpuProgramManager.klass = rb_define_class_under(mOgre, "HighLevelGpuProgramManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__HighLevelGpuProgramManager, (void *) &SwigClassHighLevelGpuProgramManager);
  rb_define_alloc_func(SwigClassHighLevelGpuProgramManager.klass, _wrap_HighLevelGpuProgramManager_allocate);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "initialize", VALUEFUNC(_wrap_new_HighLevelGpuProgramManager), -1);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "addFactory", VALUEFUNC(_wrap_HighLevelGpuProgramManager_addFactory), -1);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "removeFactory", VALUEFUNC(_wrap_HighLevelGpuProgramManager_removeFactory), -1);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "isLanguageSupported", VALUEFUNC(_wrap_HighLevelGpuProgramManager_isLanguageSupported), -1);
  rb_define_method(SwigClassHighLevelGpuProgramManager.klass, "createProgram", VALUEFUNC(_wrap_HighLevelGpuProgramManager_createProgram), -1);
  rb_define_singleton_method(SwigClassHighLevelGpuProgramManager.klass, "getSingleton", VALUEFUNC(_wrap_HighLevelGpuProgramManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassHighLevelGpuProgramManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_HighLevelGpuProgramManager_getSingletonPtr), -1);
  SwigClassHighLevelGpuProgramManager.mark = 0;
  SwigClassHighLevelGpuProgramManager.destroy = (void (*)(void *)) free_Ogre_HighLevelGpuProgramManager;
  SwigClassHighLevelGpuProgramManager.trackObjects = 0;
  
  SwigClassInstanceBatch.klass = rb_define_class_under(mOgre, "InstanceBatch", ((swig_class *) SWIGTYPE_p_Ogre__Renderable->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstanceBatch, (void *) &SwigClassInstanceBatch);
  rb_undef_alloc_func(SwigClassInstanceBatch.klass);
  rb_define_method(SwigClassInstanceBatch.klass, "_getMeshRef", VALUEFUNC(_wrap_InstanceBatch__getMeshRef), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_setInstancesPerBatch", VALUEFUNC(_wrap_InstanceBatch__setInstancesPerBatch), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_getIndexToBoneMap", VALUEFUNC(_wrap_InstanceBatch__getIndexToBoneMap), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_supportsSkeletalAnimation", VALUEFUNC(_wrap_InstanceBatch__supportsSkeletalAnimation), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_updateBounds", VALUEFUNC(_wrap_InstanceBatch__updateBounds), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "calculateMaxNumInstances", VALUEFUNC(_wrap_InstanceBatch_calculateMaxNumInstances), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "build", VALUEFUNC(_wrap_InstanceBatch_build), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "buildFrom", VALUEFUNC(_wrap_InstanceBatch_buildFrom), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_getMeshReference", VALUEFUNC(_wrap_InstanceBatch__getMeshReference), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "isBatchFull", VALUEFUNC(_wrap_InstanceBatch_isBatchFull), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "isBatchUnused", VALUEFUNC(_wrap_InstanceBatch_isBatchUnused), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getInstancedEntitiesInUse", VALUEFUNC(_wrap_InstanceBatch_getInstancedEntitiesInUse), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_defragmentBatch", VALUEFUNC(_wrap_InstanceBatch__defragmentBatch), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_defragmentBatchDiscard", VALUEFUNC(_wrap_InstanceBatch__defragmentBatchDiscard), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_boundsDirty", VALUEFUNC(_wrap_InstanceBatch__boundsDirty), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "setStaticAndUpdate", VALUEFUNC(_wrap_InstanceBatch_setStaticAndUpdate), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "isStatic", VALUEFUNC(_wrap_InstanceBatch_isStatic), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "createInstancedEntity", VALUEFUNC(_wrap_InstanceBatch_createInstancedEntity), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "removeInstancedEntity", VALUEFUNC(_wrap_InstanceBatch_removeInstancedEntity), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "useBoneWorldMatrices", VALUEFUNC(_wrap_InstanceBatch_useBoneWorldMatrices), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_markTransformSharingDirty", VALUEFUNC(_wrap_InstanceBatch__markTransformSharingDirty), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getMaterial", VALUEFUNC(_wrap_InstanceBatch_getMaterial), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getRenderOperation", VALUEFUNC(_wrap_InstanceBatch_getRenderOperation), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_InstanceBatch_getSquaredViewDepth), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getLights", VALUEFUNC(_wrap_InstanceBatch_getLights), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getTechnique", VALUEFUNC(_wrap_InstanceBatch_getTechnique), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getMovableType", VALUEFUNC(_wrap_InstanceBatch_getMovableType), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_InstanceBatch__notifyCurrentCamera), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getBoundingBox", VALUEFUNC(_wrap_InstanceBatch_getBoundingBox), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "getBoundingRadius", VALUEFUNC(_wrap_InstanceBatch_getBoundingRadius), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "_updateRenderQueue", VALUEFUNC(_wrap_InstanceBatch__updateRenderQueue), -1);
  rb_define_method(SwigClassInstanceBatch.klass, "visitRenderables", VALUEFUNC(_wrap_InstanceBatch_visitRenderables), -1);
  SwigClassInstanceBatch.mark = 0;
  SwigClassInstanceBatch.destroy = (void (*)(void *)) free_Ogre_InstanceBatch;
  SwigClassInstanceBatch.trackObjects = 0;
  
  SwigClassInstanceBatchHW.klass = rb_define_class_under(mOgre, "InstanceBatchHW", ((swig_class *) SWIGTYPE_p_Ogre__InstanceBatch->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstanceBatchHW, (void *) &SwigClassInstanceBatchHW);
  rb_define_alloc_func(SwigClassInstanceBatchHW.klass, _wrap_InstanceBatchHW_allocate);
  rb_define_method(SwigClassInstanceBatchHW.klass, "initialize", VALUEFUNC(_wrap_new_InstanceBatchHW), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "calculateMaxNumInstances", VALUEFUNC(_wrap_InstanceBatchHW_calculateMaxNumInstances), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "buildFrom", VALUEFUNC(_wrap_InstanceBatchHW_buildFrom), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "_boundsDirty", VALUEFUNC(_wrap_InstanceBatchHW__boundsDirty), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "setStaticAndUpdate", VALUEFUNC(_wrap_InstanceBatchHW_setStaticAndUpdate), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "isStatic", VALUEFUNC(_wrap_InstanceBatchHW_isStatic), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "getWorldTransforms", VALUEFUNC(_wrap_InstanceBatchHW_getWorldTransforms), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "getNumWorldTransforms", VALUEFUNC(_wrap_InstanceBatchHW_getNumWorldTransforms), -1);
  rb_define_method(SwigClassInstanceBatchHW.klass, "_updateRenderQueue", VALUEFUNC(_wrap_InstanceBatchHW__updateRenderQueue), -1);
  SwigClassInstanceBatchHW.mark = 0;
  SwigClassInstanceBatchHW.destroy = (void (*)(void *)) free_Ogre_InstanceBatchHW;
  SwigClassInstanceBatchHW.trackObjects = 0;
  
  SwigClassBaseInstanceBatchVTF.klass = rb_define_class_under(mOgre, "BaseInstanceBatchVTF", ((swig_class *) SWIGTYPE_p_Ogre__InstanceBatch->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BaseInstanceBatchVTF, (void *) &SwigClassBaseInstanceBatchVTF);
  rb_undef_alloc_func(SwigClassBaseInstanceBatchVTF.klass);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "buildFrom", VALUEFUNC(_wrap_BaseInstanceBatchVTF_buildFrom), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "getWorldTransforms", VALUEFUNC(_wrap_BaseInstanceBatchVTF_getWorldTransforms), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "getNumWorldTransforms", VALUEFUNC(_wrap_BaseInstanceBatchVTF_getNumWorldTransforms), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "_updateRenderQueue", VALUEFUNC(_wrap_BaseInstanceBatchVTF__updateRenderQueue), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "setBoneMatrixLookup", VALUEFUNC(_wrap_BaseInstanceBatchVTF_setBoneMatrixLookup), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "useBoneMatrixLookup", VALUEFUNC(_wrap_BaseInstanceBatchVTF_useBoneMatrixLookup), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "setBoneDualQuaternions", VALUEFUNC(_wrap_BaseInstanceBatchVTF_setBoneDualQuaternions), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "useBoneDualQuaternions", VALUEFUNC(_wrap_BaseInstanceBatchVTF_useBoneDualQuaternions), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "setForceOneWeight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_setForceOneWeight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "forceOneWeight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_forceOneWeight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "setUseOneWeight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_setUseOneWeight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "useOneWeight", VALUEFUNC(_wrap_BaseInstanceBatchVTF_useOneWeight), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "useBoneWorldMatrices", VALUEFUNC(_wrap_BaseInstanceBatchVTF_useBoneWorldMatrices), -1);
  rb_define_method(SwigClassBaseInstanceBatchVTF.klass, "getMaxLookupTableInstances", VALUEFUNC(_wrap_BaseInstanceBatchVTF_getMaxLookupTableInstances), -1);
  SwigClassBaseInstanceBatchVTF.mark = 0;
  SwigClassBaseInstanceBatchVTF.destroy = (void (*)(void *)) free_Ogre_BaseInstanceBatchVTF;
  SwigClassBaseInstanceBatchVTF.trackObjects = 0;
  
  SwigClassInstanceBatchVTF.klass = rb_define_class_under(mOgre, "InstanceBatchVTF", ((swig_class *) SWIGTYPE_p_Ogre__BaseInstanceBatchVTF->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstanceBatchVTF, (void *) &SwigClassInstanceBatchVTF);
  rb_define_alloc_func(SwigClassInstanceBatchVTF.klass, _wrap_InstanceBatchVTF_allocate);
  rb_define_method(SwigClassInstanceBatchVTF.klass, "initialize", VALUEFUNC(_wrap_new_InstanceBatchVTF), -1);
  rb_define_method(SwigClassInstanceBatchVTF.klass, "calculateMaxNumInstances", VALUEFUNC(_wrap_InstanceBatchVTF_calculateMaxNumInstances), -1);
  SwigClassInstanceBatchVTF.mark = 0;
  SwigClassInstanceBatchVTF.destroy = (void (*)(void *)) free_Ogre_InstanceBatchVTF;
  SwigClassInstanceBatchVTF.trackObjects = 0;
  
  SwigClassInstanceBatchHW_VTF.klass = rb_define_class_under(mOgre, "InstanceBatchHW_VTF", ((swig_class *) SWIGTYPE_p_Ogre__BaseInstanceBatchVTF->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstanceBatchHW_VTF, (void *) &SwigClassInstanceBatchHW_VTF);
  rb_define_alloc_func(SwigClassInstanceBatchHW_VTF.klass, _wrap_InstanceBatchHW_VTF_allocate);
  rb_define_method(SwigClassInstanceBatchHW_VTF.klass, "initialize", VALUEFUNC(_wrap_new_InstanceBatchHW_VTF), -1);
  rb_define_method(SwigClassInstanceBatchHW_VTF.klass, "calculateMaxNumInstances", VALUEFUNC(_wrap_InstanceBatchHW_VTF_calculateMaxNumInstances), -1);
  rb_define_method(SwigClassInstanceBatchHW_VTF.klass, "_boundsDirty", VALUEFUNC(_wrap_InstanceBatchHW_VTF__boundsDirty), -1);
  rb_define_method(SwigClassInstanceBatchHW_VTF.klass, "setStaticAndUpdate", VALUEFUNC(_wrap_InstanceBatchHW_VTF_setStaticAndUpdate), -1);
  rb_define_method(SwigClassInstanceBatchHW_VTF.klass, "isStatic", VALUEFUNC(_wrap_InstanceBatchHW_VTF_isStatic), -1);
  rb_define_method(SwigClassInstanceBatchHW_VTF.klass, "_updateRenderQueue", VALUEFUNC(_wrap_InstanceBatchHW_VTF__updateRenderQueue), -1);
  SwigClassInstanceBatchHW_VTF.mark = 0;
  SwigClassInstanceBatchHW_VTF.destroy = (void (*)(void *)) free_Ogre_InstanceBatchHW_VTF;
  SwigClassInstanceBatchHW_VTF.trackObjects = 0;
  
  SwigClassInstanceBatchShader.klass = rb_define_class_under(mOgre, "InstanceBatchShader", ((swig_class *) SWIGTYPE_p_Ogre__InstanceBatch->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstanceBatchShader, (void *) &SwigClassInstanceBatchShader);
  rb_define_alloc_func(SwigClassInstanceBatchShader.klass, _wrap_InstanceBatchShader_allocate);
  rb_define_method(SwigClassInstanceBatchShader.klass, "initialize", VALUEFUNC(_wrap_new_InstanceBatchShader), -1);
  rb_define_method(SwigClassInstanceBatchShader.klass, "calculateMaxNumInstances", VALUEFUNC(_wrap_InstanceBatchShader_calculateMaxNumInstances), -1);
  rb_define_method(SwigClassInstanceBatchShader.klass, "buildFrom", VALUEFUNC(_wrap_InstanceBatchShader_buildFrom), -1);
  rb_define_method(SwigClassInstanceBatchShader.klass, "getWorldTransforms", VALUEFUNC(_wrap_InstanceBatchShader_getWorldTransforms), -1);
  rb_define_method(SwigClassInstanceBatchShader.klass, "getNumWorldTransforms", VALUEFUNC(_wrap_InstanceBatchShader_getNumWorldTransforms), -1);
  SwigClassInstanceBatchShader.mark = 0;
  SwigClassInstanceBatchShader.destroy = (void (*)(void *)) free_Ogre_InstanceBatchShader;
  SwigClassInstanceBatchShader.trackObjects = 0;
  
  SwigClassInstanceManager.klass = rb_define_class_under(mOgre, "InstanceManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstanceManager, (void *) &SwigClassInstanceManager);
  rb_define_alloc_func(SwigClassInstanceManager.klass, _wrap_InstanceManager_allocate);
  rb_define_method(SwigClassInstanceManager.klass, "initialize", VALUEFUNC(_wrap_new_InstanceManager), -1);
  rb_define_const(SwigClassInstanceManager.klass, "ShaderBased", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::ShaderBased)));
  rb_define_const(SwigClassInstanceManager.klass, "TextureVTF", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::TextureVTF)));
  rb_define_const(SwigClassInstanceManager.klass, "HWInstancingBasic", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::HWInstancingBasic)));
  rb_define_const(SwigClassInstanceManager.klass, "HWInstancingVTF", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::HWInstancingVTF)));
  rb_define_const(SwigClassInstanceManager.klass, "InstancingTechniquesCount", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::InstancingTechniquesCount)));
  rb_define_const(SwigClassInstanceManager.klass, "CAST_SHADOWS", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::CAST_SHADOWS)));
  rb_define_const(SwigClassInstanceManager.klass, "SHOW_BOUNDINGBOX", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::SHOW_BOUNDINGBOX)));
  rb_define_const(SwigClassInstanceManager.klass, "NUM_SETTINGS", SWIG_From_int(static_cast< int >(Ogre::InstanceManager::NUM_SETTINGS)));
  rb_define_method(SwigClassInstanceManager.klass, "getName", VALUEFUNC(_wrap_InstanceManager_getName), -1);
  rb_define_method(SwigClassInstanceManager.klass, "setInstancesPerBatch", VALUEFUNC(_wrap_InstanceManager_setInstancesPerBatch), -1);
  rb_define_method(SwigClassInstanceManager.klass, "setMaxLookupTableInstances", VALUEFUNC(_wrap_InstanceManager_setMaxLookupTableInstances), -1);
  rb_define_method(SwigClassInstanceManager.klass, "getMaxOrBestNumInstancesPerBatch", VALUEFUNC(_wrap_InstanceManager_getMaxOrBestNumInstancesPerBatch), -1);
  rb_define_method(SwigClassInstanceManager.klass, "createInstancedEntity", VALUEFUNC(_wrap_InstanceManager_createInstancedEntity), -1);
  rb_define_method(SwigClassInstanceManager.klass, "cleanupEmptyBatches", VALUEFUNC(_wrap_InstanceManager_cleanupEmptyBatches), -1);
  rb_define_method(SwigClassInstanceManager.klass, "defragmentBatches", VALUEFUNC(_wrap_InstanceManager_defragmentBatches), -1);
  rb_define_method(SwigClassInstanceManager.klass, "setSetting", VALUEFUNC(_wrap_InstanceManager_setSetting), -1);
  rb_define_method(SwigClassInstanceManager.klass, "getSetting", VALUEFUNC(_wrap_InstanceManager_getSetting), -1);
  rb_define_method(SwigClassInstanceManager.klass, "hasSettings", VALUEFUNC(_wrap_InstanceManager_hasSettings), -1);
  rb_define_method(SwigClassInstanceManager.klass, "setBatchesAsStaticAndUpdate", VALUEFUNC(_wrap_InstanceManager_setBatchesAsStaticAndUpdate), -1);
  rb_define_method(SwigClassInstanceManager.klass, "_addDirtyBatch", VALUEFUNC(_wrap_InstanceManager__addDirtyBatch), -1);
  rb_define_method(SwigClassInstanceManager.klass, "_updateDirtyBatches", VALUEFUNC(_wrap_InstanceManager__updateDirtyBatches), -1);
  rb_define_method(SwigClassInstanceManager.klass, "getInstanceBatchMapIterator", VALUEFUNC(_wrap_InstanceManager_getInstanceBatchMapIterator), -1);
  rb_define_method(SwigClassInstanceManager.klass, "getInstanceBatchIterator", VALUEFUNC(_wrap_InstanceManager_getInstanceBatchIterator), -1);
  SwigClassInstanceManager.mark = 0;
  SwigClassInstanceManager.destroy = (void (*)(void *)) free_Ogre_InstanceManager;
  SwigClassInstanceManager.trackObjects = 0;
  
  SwigClassInstancedEntity.klass = rb_define_class_under(mOgre, "InstancedEntity", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstancedEntity, (void *) &SwigClassInstancedEntity);
  rb_define_alloc_func(SwigClassInstancedEntity.klass, _wrap_InstancedEntity_allocate);
  rb_define_method(SwigClassInstancedEntity.klass, "initialize", VALUEFUNC(_wrap_new_InstancedEntity), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "shareTransformWith", VALUEFUNC(_wrap_InstancedEntity_shareTransformWith), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "stopSharingTransform", VALUEFUNC(_wrap_InstancedEntity_stopSharingTransform), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_getOwner", VALUEFUNC(_wrap_InstancedEntity__getOwner), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getMovableType", VALUEFUNC(_wrap_InstancedEntity_getMovableType), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getBoundingBox", VALUEFUNC(_wrap_InstancedEntity_getBoundingBox), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getBoundingRadius", VALUEFUNC(_wrap_InstancedEntity_getBoundingRadius), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_InstancedEntity_getSquaredViewDepth), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_notifyMoved", VALUEFUNC(_wrap_InstancedEntity__notifyMoved), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_notifyAttached", VALUEFUNC(_wrap_InstancedEntity__notifyAttached), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_updateRenderQueue", VALUEFUNC(_wrap_InstancedEntity__updateRenderQueue), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "visitRenderables", VALUEFUNC(_wrap_InstancedEntity_visitRenderables), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "hasSkeleton", VALUEFUNC(_wrap_InstancedEntity_hasSkeleton), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getSkeleton", VALUEFUNC(_wrap_InstancedEntity_getSkeleton), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getAnimationState", VALUEFUNC(_wrap_InstancedEntity_getAnimationState), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getAllAnimationStates", VALUEFUNC(_wrap_InstancedEntity_getAllAnimationStates), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_updateAnimation", VALUEFUNC(_wrap_InstancedEntity__updateAnimation), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "setTransformLookupNumber", VALUEFUNC(_wrap_InstancedEntity_setTransformLookupNumber), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getPosition", VALUEFUNC(_wrap_InstancedEntity_getPosition), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "setPosition", VALUEFUNC(_wrap_InstancedEntity_setPosition), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getOrientation", VALUEFUNC(_wrap_InstancedEntity_getOrientation), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "setOrientation", VALUEFUNC(_wrap_InstancedEntity_setOrientation), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getScale", VALUEFUNC(_wrap_InstancedEntity_getScale), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "setScale", VALUEFUNC(_wrap_InstancedEntity_setScale), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "getMaxScaleCoef", VALUEFUNC(_wrap_InstancedEntity_getMaxScaleCoef), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "updateTransforms", VALUEFUNC(_wrap_InstancedEntity_updateTransforms), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "isInUse", VALUEFUNC(_wrap_InstancedEntity_isInUse), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "setInUse", VALUEFUNC(_wrap_InstancedEntity_setInUse), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_getParentNodeFullTransform", VALUEFUNC(_wrap_InstancedEntity__getParentNodeFullTransform), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "_getDerivedPosition", VALUEFUNC(_wrap_InstancedEntity__getDerivedPosition), -1);
  rb_define_method(SwigClassInstancedEntity.klass, "isInScene", VALUEFUNC(_wrap_InstancedEntity_isInScene), -1);
  SwigClassInstancedEntity.mark = 0;
  SwigClassInstancedEntity.destroy = (void (*)(void *)) free_Ogre_InstancedEntity;
  SwigClassInstancedEntity.trackObjects = 0;
  
  SwigClassSimpleRenderable.klass = rb_define_class_under(mOgre, "SimpleRenderable", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SimpleRenderable, (void *) &SwigClassSimpleRenderable);
  rb_undef_alloc_func(SwigClassSimpleRenderable.klass);
  rb_define_method(SwigClassSimpleRenderable.klass, "setMaterial", VALUEFUNC(_wrap_SimpleRenderable_setMaterial), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "getMaterial", VALUEFUNC(_wrap_SimpleRenderable_getMaterial), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "setRenderOperation", VALUEFUNC(_wrap_SimpleRenderable_setRenderOperation), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "getRenderOperation", VALUEFUNC(_wrap_SimpleRenderable_getRenderOperation), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "setWorldTransform", VALUEFUNC(_wrap_SimpleRenderable_setWorldTransform), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "getWorldTransforms", VALUEFUNC(_wrap_SimpleRenderable_getWorldTransforms), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_SimpleRenderable__notifyCurrentCamera), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "setBoundingBox", VALUEFUNC(_wrap_SimpleRenderable_setBoundingBox), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "getBoundingBox", VALUEFUNC(_wrap_SimpleRenderable_getBoundingBox), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "_updateRenderQueue", VALUEFUNC(_wrap_SimpleRenderable__updateRenderQueue), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "visitRenderables", VALUEFUNC(_wrap_SimpleRenderable_visitRenderables), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "getMovableType", VALUEFUNC(_wrap_SimpleRenderable_getMovableType), -1);
  rb_define_method(SwigClassSimpleRenderable.klass, "getLights", VALUEFUNC(_wrap_SimpleRenderable_getLights), -1);
  SwigClassSimpleRenderable.mark = 0;
  SwigClassSimpleRenderable.destroy = (void (*)(void *)) free_Ogre_SimpleRenderable;
  SwigClassSimpleRenderable.trackObjects = 0;
  
  SwigClassSkeletonInstance.klass = rb_define_class_under(mOgre, "SkeletonInstance", ((swig_class *) SWIGTYPE_p_Ogre__Skeleton->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SkeletonInstance, (void *) &SwigClassSkeletonInstance);
  rb_define_alloc_func(SwigClassSkeletonInstance.klass, _wrap_SkeletonInstance_allocate);
  rb_define_method(SwigClassSkeletonInstance.klass, "initialize", VALUEFUNC(_wrap_new_SkeletonInstance), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "getNumAnimations", VALUEFUNC(_wrap_SkeletonInstance_getNumAnimations), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "_getAnimationImpl", VALUEFUNC(_wrap_SkeletonInstance__getAnimationImpl), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "createAnimation", VALUEFUNC(_wrap_SkeletonInstance_createAnimation), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "getAnimation", VALUEFUNC(_wrap_SkeletonInstance_getAnimation), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "removeAnimation", VALUEFUNC(_wrap_SkeletonInstance_removeAnimation), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "createTagPointOnBone", VALUEFUNC(_wrap_SkeletonInstance_createTagPointOnBone), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "freeTagPoint", VALUEFUNC(_wrap_SkeletonInstance_freeTagPoint), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "addLinkedSkeletonAnimationSource", VALUEFUNC(_wrap_SkeletonInstance_addLinkedSkeletonAnimationSource), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "removeAllLinkedSkeletonAnimationSources", VALUEFUNC(_wrap_SkeletonInstance_removeAllLinkedSkeletonAnimationSources), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "getLinkedSkeletonAnimationSourceIterator", VALUEFUNC(_wrap_SkeletonInstance_getLinkedSkeletonAnimationSourceIterator), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "_initAnimationState", VALUEFUNC(_wrap_SkeletonInstance__initAnimationState), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "_refreshAnimationState", VALUEFUNC(_wrap_SkeletonInstance__refreshAnimationState), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "getName", VALUEFUNC(_wrap_SkeletonInstance_getName), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "getHandle", VALUEFUNC(_wrap_SkeletonInstance_getHandle), -1);
  rb_define_method(SwigClassSkeletonInstance.klass, "getGroup", VALUEFUNC(_wrap_SkeletonInstance_getGroup), -1);
  SwigClassSkeletonInstance.mark = 0;
  SwigClassSkeletonInstance.destroy = (void (*)(void *)) free_Ogre_SkeletonInstance;
  SwigClassSkeletonInstance.trackObjects = 0;
  
  SwigClassInstancedGeometry.klass = rb_define_class_under(mOgre, "InstancedGeometry", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__InstancedGeometry, (void *) &SwigClassInstancedGeometry);
  rb_define_alloc_func(SwigClassInstancedGeometry.klass, _wrap_InstancedGeometry_allocate);
  rb_define_method(SwigClassInstancedGeometry.klass, "initialize", VALUEFUNC(_wrap_new_InstancedGeometry), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getName", VALUEFUNC(_wrap_InstancedGeometry_getName), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "addEntity", VALUEFUNC(_wrap_InstancedGeometry_addEntity), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "addSceneNode", VALUEFUNC(_wrap_InstancedGeometry_addSceneNode), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "build", VALUEFUNC(_wrap_InstancedGeometry_build), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "addBatchInstance", VALUEFUNC(_wrap_InstancedGeometry_addBatchInstance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "destroy", VALUEFUNC(_wrap_InstancedGeometry_destroy), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "reset", VALUEFUNC(_wrap_InstancedGeometry_reset), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "setRenderingDistance", VALUEFUNC(_wrap_InstancedGeometry_setRenderingDistance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getRenderingDistance", VALUEFUNC(_wrap_InstancedGeometry_getRenderingDistance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getSquaredRenderingDistance", VALUEFUNC(_wrap_InstancedGeometry_getSquaredRenderingDistance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "setVisible", VALUEFUNC(_wrap_InstancedGeometry_setVisible), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "isVisible", VALUEFUNC(_wrap_InstancedGeometry_isVisible), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "setCastShadows", VALUEFUNC(_wrap_InstancedGeometry_setCastShadows), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getCastShadows", VALUEFUNC(_wrap_InstancedGeometry_getCastShadows), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "setBatchInstanceDimensions", VALUEFUNC(_wrap_InstancedGeometry_setBatchInstanceDimensions), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getBatchInstanceDimensions", VALUEFUNC(_wrap_InstancedGeometry_getBatchInstanceDimensions), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "setOrigin", VALUEFUNC(_wrap_InstancedGeometry_setOrigin), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getOrigin", VALUEFUNC(_wrap_InstancedGeometry_getOrigin), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_InstancedGeometry_setRenderQueueGroup), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getRenderQueueGroup", VALUEFUNC(_wrap_InstancedGeometry_getRenderQueueGroup), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getBatchInstanceIterator", VALUEFUNC(_wrap_InstancedGeometry_getBatchInstanceIterator), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getRenderOperationVector", VALUEFUNC(_wrap_InstancedGeometry_getRenderOperationVector), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "visitRenderables", VALUEFUNC(_wrap_InstancedGeometry_visitRenderables), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "dump", VALUEFUNC(_wrap_InstancedGeometry_dump), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getBaseSkeletonInstance", VALUEFUNC(_wrap_InstancedGeometry_getBaseSkeletonInstance), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getBaseSkeleton", VALUEFUNC(_wrap_InstancedGeometry_getBaseSkeleton), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getBaseAnimationState", VALUEFUNC(_wrap_InstancedGeometry_getBaseAnimationState), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getObjectCount", VALUEFUNC(_wrap_InstancedGeometry_getObjectCount), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "setProvideWorldInverses", VALUEFUNC(_wrap_InstancedGeometry_setProvideWorldInverses), -1);
  rb_define_method(SwigClassInstancedGeometry.klass, "getProvideWorldInverses", VALUEFUNC(_wrap_InstancedGeometry_getProvideWorldInverses), -1);
  SwigClassInstancedGeometry.mark = 0;
  SwigClassInstancedGeometry.destroy = (void (*)(void *)) free_Ogre_InstancedGeometry;
  SwigClassInstancedGeometry.trackObjects = 0;
  
  SwigClassMovableObjectLodChangedEvent.klass = rb_define_class_under(mOgre, "MovableObjectLodChangedEvent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MovableObjectLodChangedEvent, (void *) &SwigClassMovableObjectLodChangedEvent);
  rb_define_alloc_func(SwigClassMovableObjectLodChangedEvent.klass, _wrap_MovableObjectLodChangedEvent_allocate);
  rb_define_method(SwigClassMovableObjectLodChangedEvent.klass, "initialize", VALUEFUNC(_wrap_new_MovableObjectLodChangedEvent), -1);
  rb_define_method(SwigClassMovableObjectLodChangedEvent.klass, "movableObject=", VALUEFUNC(_wrap_MovableObjectLodChangedEvent_movableObject_set), -1);
  rb_define_method(SwigClassMovableObjectLodChangedEvent.klass, "movableObject", VALUEFUNC(_wrap_MovableObjectLodChangedEvent_movableObject_get), -1);
  rb_define_method(SwigClassMovableObjectLodChangedEvent.klass, "camera=", VALUEFUNC(_wrap_MovableObjectLodChangedEvent_camera_set), -1);
  rb_define_method(SwigClassMovableObjectLodChangedEvent.klass, "camera", VALUEFUNC(_wrap_MovableObjectLodChangedEvent_camera_get), -1);
  SwigClassMovableObjectLodChangedEvent.mark = 0;
  SwigClassMovableObjectLodChangedEvent.destroy = (void (*)(void *)) free_Ogre_MovableObjectLodChangedEvent;
  SwigClassMovableObjectLodChangedEvent.trackObjects = 0;
  
  SwigClassEntityMeshLodChangedEvent.klass = rb_define_class_under(mOgre, "EntityMeshLodChangedEvent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EntityMeshLodChangedEvent, (void *) &SwigClassEntityMeshLodChangedEvent);
  rb_define_alloc_func(SwigClassEntityMeshLodChangedEvent.klass, _wrap_EntityMeshLodChangedEvent_allocate);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "initialize", VALUEFUNC(_wrap_new_EntityMeshLodChangedEvent), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "entity=", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_entity_set), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "entity", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_entity_get), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "camera=", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_camera_set), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "camera", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_camera_get), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "lodValue=", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_lodValue_set), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "lodValue", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_lodValue_get), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "previousLodIndex=", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_previousLodIndex_set), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "previousLodIndex", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_previousLodIndex_get), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "newLodIndex=", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_newLodIndex_set), -1);
  rb_define_method(SwigClassEntityMeshLodChangedEvent.klass, "newLodIndex", VALUEFUNC(_wrap_EntityMeshLodChangedEvent_newLodIndex_get), -1);
  SwigClassEntityMeshLodChangedEvent.mark = 0;
  SwigClassEntityMeshLodChangedEvent.destroy = (void (*)(void *)) free_Ogre_EntityMeshLodChangedEvent;
  SwigClassEntityMeshLodChangedEvent.trackObjects = 0;
  
  SwigClassEntityMaterialLodChangedEvent.klass = rb_define_class_under(mOgre, "EntityMaterialLodChangedEvent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EntityMaterialLodChangedEvent, (void *) &SwigClassEntityMaterialLodChangedEvent);
  rb_define_alloc_func(SwigClassEntityMaterialLodChangedEvent.klass, _wrap_EntityMaterialLodChangedEvent_allocate);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "initialize", VALUEFUNC(_wrap_new_EntityMaterialLodChangedEvent), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "subEntity=", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_subEntity_set), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "subEntity", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_subEntity_get), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "camera=", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_camera_set), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "camera", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_camera_get), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "lodValue=", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_lodValue_set), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "lodValue", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_lodValue_get), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "previousLodIndex=", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_previousLodIndex_set), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "previousLodIndex", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_previousLodIndex_get), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "newLodIndex=", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_newLodIndex_set), -1);
  rb_define_method(SwigClassEntityMaterialLodChangedEvent.klass, "newLodIndex", VALUEFUNC(_wrap_EntityMaterialLodChangedEvent_newLodIndex_get), -1);
  SwigClassEntityMaterialLodChangedEvent.mark = 0;
  SwigClassEntityMaterialLodChangedEvent.destroy = (void (*)(void *)) free_Ogre_EntityMaterialLodChangedEvent;
  SwigClassEntityMaterialLodChangedEvent.trackObjects = 0;
  rb_define_module_function(mOgre, "disown_LodListener", VALUEFUNC(_wrap_disown_LodListener), -1);
  
  SwigClassLodListener.klass = rb_define_class_under(mOgre, "LodListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LodListener, (void *) &SwigClassLodListener);
  rb_define_alloc_func(SwigClassLodListener.klass, _wrap_LodListener_allocate);
  rb_define_method(SwigClassLodListener.klass, "initialize", VALUEFUNC(_wrap_new_LodListener), -1);
  rb_define_method(SwigClassLodListener.klass, "prequeueMovableObjectLodChanged", VALUEFUNC(_wrap_LodListener_prequeueMovableObjectLodChanged), -1);
  rb_define_method(SwigClassLodListener.klass, "postqueueMovableObjectLodChanged", VALUEFUNC(_wrap_LodListener_postqueueMovableObjectLodChanged), -1);
  rb_define_method(SwigClassLodListener.klass, "prequeueEntityMeshLodChanged", VALUEFUNC(_wrap_LodListener_prequeueEntityMeshLodChanged), -1);
  rb_define_method(SwigClassLodListener.klass, "postqueueEntityMeshLodChanged", VALUEFUNC(_wrap_LodListener_postqueueEntityMeshLodChanged), -1);
  rb_define_method(SwigClassLodListener.klass, "prequeueEntityMaterialLodChanged", VALUEFUNC(_wrap_LodListener_prequeueEntityMaterialLodChanged), -1);
  rb_define_method(SwigClassLodListener.klass, "postqueueEntityMaterialLodChanged", VALUEFUNC(_wrap_LodListener_postqueueEntityMaterialLodChanged), -1);
  SwigClassLodListener.mark = 0;
  SwigClassLodListener.destroy = (void (*)(void *)) free_Ogre_LodListener;
  SwigClassLodListener.trackObjects = 0;
  
  SwigClassLodStrategyManager.klass = rb_define_class_under(mOgre, "LodStrategyManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LodStrategyManager, (void *) &SwigClassLodStrategyManager);
  rb_define_alloc_func(SwigClassLodStrategyManager.klass, _wrap_LodStrategyManager_allocate);
  rb_define_method(SwigClassLodStrategyManager.klass, "initialize", VALUEFUNC(_wrap_new_LodStrategyManager), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "addStrategy", VALUEFUNC(_wrap_LodStrategyManager_addStrategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "removeStrategy", VALUEFUNC(_wrap_LodStrategyManager_removeStrategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "removeAllStrategies", VALUEFUNC(_wrap_LodStrategyManager_removeAllStrategies), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "getStrategy", VALUEFUNC(_wrap_LodStrategyManager_getStrategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "setDefaultStrategy", VALUEFUNC(_wrap_LodStrategyManager_setDefaultStrategy), -1);
  rb_define_method(SwigClassLodStrategyManager.klass, "getDefaultStrategy", VALUEFUNC(_wrap_LodStrategyManager_getDefaultStrategy), -1);
  rb_define_singleton_method(SwigClassLodStrategyManager.klass, "getSingleton", VALUEFUNC(_wrap_LodStrategyManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassLodStrategyManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_LodStrategyManager_getSingletonPtr), -1);
  SwigClassLodStrategyManager.mark = 0;
  SwigClassLodStrategyManager.destroy = (void (*)(void *)) free_Ogre_LodStrategyManager;
  SwigClassLodStrategyManager.trackObjects = 0;
  
  SwigClassManualObject.klass = rb_define_class_under(mOgre, "ManualObject", ((swig_class *) SWIGTYPE_p_Ogre__MovableObject->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ManualObject, (void *) &SwigClassManualObject);
  rb_define_alloc_func(SwigClassManualObject.klass, _wrap_ManualObject_allocate);
  rb_define_method(SwigClassManualObject.klass, "initialize", VALUEFUNC(_wrap_new_ManualObject), -1);
  rb_define_method(SwigClassManualObject.klass, "clear", VALUEFUNC(_wrap_ManualObject_clear), -1);
  rb_define_method(SwigClassManualObject.klass, "estimateVertexCount", VALUEFUNC(_wrap_ManualObject_estimateVertexCount), -1);
  rb_define_method(SwigClassManualObject.klass, "estimateIndexCount", VALUEFUNC(_wrap_ManualObject_estimateIndexCount), -1);
  rb_define_method(SwigClassManualObject.klass, "begin", VALUEFUNC(_wrap_ManualObject_begin), -1);
  rb_define_method(SwigClassManualObject.klass, "setDynamic", VALUEFUNC(_wrap_ManualObject_setDynamic), -1);
  rb_define_method(SwigClassManualObject.klass, "getDynamic", VALUEFUNC(_wrap_ManualObject_getDynamic), -1);
  rb_define_method(SwigClassManualObject.klass, "beginUpdate", VALUEFUNC(_wrap_ManualObject_beginUpdate), -1);
  rb_define_method(SwigClassManualObject.klass, "position", VALUEFUNC(_wrap_ManualObject_position), -1);
  rb_define_method(SwigClassManualObject.klass, "normal", VALUEFUNC(_wrap_ManualObject_normal), -1);
  rb_define_method(SwigClassManualObject.klass, "tangent", VALUEFUNC(_wrap_ManualObject_tangent), -1);
  rb_define_method(SwigClassManualObject.klass, "textureCoord", VALUEFUNC(_wrap_ManualObject_textureCoord), -1);
  rb_define_method(SwigClassManualObject.klass, "colour", VALUEFUNC(_wrap_ManualObject_colour), -1);
  rb_define_method(SwigClassManualObject.klass, "index", VALUEFUNC(_wrap_ManualObject_index), -1);
  rb_define_method(SwigClassManualObject.klass, "triangle", VALUEFUNC(_wrap_ManualObject_triangle), -1);
  rb_define_method(SwigClassManualObject.klass, "quad", VALUEFUNC(_wrap_ManualObject_quad), -1);
  rb_define_method(SwigClassManualObject.klass, "getCurrentVertexCount", VALUEFUNC(_wrap_ManualObject_getCurrentVertexCount), -1);
  rb_define_method(SwigClassManualObject.klass, "getCurrentIndexCount", VALUEFUNC(_wrap_ManualObject_getCurrentIndexCount), -1);
  rb_define_method(SwigClassManualObject.klass, "end", VALUEFUNC(_wrap_ManualObject_end), -1);
  rb_define_method(SwigClassManualObject.klass, "setMaterialName", VALUEFUNC(_wrap_ManualObject_setMaterialName), -1);
  rb_define_method(SwigClassManualObject.klass, "convertToMesh", VALUEFUNC(_wrap_ManualObject_convertToMesh), -1);
  rb_define_method(SwigClassManualObject.klass, "setUseIdentityProjection", VALUEFUNC(_wrap_ManualObject_setUseIdentityProjection), -1);
  rb_define_method(SwigClassManualObject.klass, "getUseIdentityProjection", VALUEFUNC(_wrap_ManualObject_getUseIdentityProjection), -1);
  rb_define_method(SwigClassManualObject.klass, "setUseIdentityView", VALUEFUNC(_wrap_ManualObject_setUseIdentityView), -1);
  rb_define_method(SwigClassManualObject.klass, "getUseIdentityView", VALUEFUNC(_wrap_ManualObject_getUseIdentityView), -1);
  rb_define_method(SwigClassManualObject.klass, "setBoundingBox", VALUEFUNC(_wrap_ManualObject_setBoundingBox), -1);
  rb_define_method(SwigClassManualObject.klass, "getSection", VALUEFUNC(_wrap_ManualObject_getSection), -1);
  rb_define_method(SwigClassManualObject.klass, "getNumSections", VALUEFUNC(_wrap_ManualObject_getNumSections), -1);
  rb_define_method(SwigClassManualObject.klass, "setKeepDeclarationOrder", VALUEFUNC(_wrap_ManualObject_setKeepDeclarationOrder), -1);
  rb_define_method(SwigClassManualObject.klass, "getKeepDeclarationOrder", VALUEFUNC(_wrap_ManualObject_getKeepDeclarationOrder), -1);
  rb_define_method(SwigClassManualObject.klass, "getMovableType", VALUEFUNC(_wrap_ManualObject_getMovableType), -1);
  rb_define_method(SwigClassManualObject.klass, "getBoundingBox", VALUEFUNC(_wrap_ManualObject_getBoundingBox), -1);
  rb_define_method(SwigClassManualObject.klass, "getBoundingRadius", VALUEFUNC(_wrap_ManualObject_getBoundingRadius), -1);
  rb_define_method(SwigClassManualObject.klass, "_updateRenderQueue", VALUEFUNC(_wrap_ManualObject__updateRenderQueue), -1);
  rb_define_method(SwigClassManualObject.klass, "getEdgeList", VALUEFUNC(_wrap_ManualObject_getEdgeList), -1);
  rb_define_method(SwigClassManualObject.klass, "hasEdgeList", VALUEFUNC(_wrap_ManualObject_hasEdgeList), -1);
  rb_define_method(SwigClassManualObject.klass, "getShadowVolumeRenderableIterator", VALUEFUNC(_wrap_ManualObject_getShadowVolumeRenderableIterator), -1);
  rb_define_method(SwigClassManualObject.klass, "visitRenderables", VALUEFUNC(_wrap_ManualObject_visitRenderables), -1);
  SwigClassManualObject.mark = 0;
  SwigClassManualObject.destroy = (void (*)(void *)) free_Ogre_ManualObject;
  SwigClassManualObject.trackObjects = 0;
  
  SwigClassManualObjectFactory.klass = rb_define_class_under(mOgre, "ManualObjectFactory", ((swig_class *) SWIGTYPE_p_Ogre__MovableObjectFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ManualObjectFactory, (void *) &SwigClassManualObjectFactory);
  rb_undef_alloc_func(SwigClassManualObjectFactory.klass);
  rb_define_singleton_method(SwigClassManualObjectFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_ManualObjectFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_singleton_method(SwigClassManualObjectFactory.klass, "FACTORY_TYPE_NAME=", VALUEFUNC(_wrap_ManualObjectFactory_FACTORY_TYPE_NAME_set), 1);
  rb_define_method(SwigClassManualObjectFactory.klass, "getType", VALUEFUNC(_wrap_ManualObjectFactory_getType), -1);
  rb_define_method(SwigClassManualObjectFactory.klass, "destroyInstance", VALUEFUNC(_wrap_ManualObjectFactory_destroyInstance), -1);
  SwigClassManualObjectFactory.mark = 0;
  SwigClassManualObjectFactory.destroy = (void (*)(void *)) free_Ogre_ManualObjectFactory;
  SwigClassManualObjectFactory.trackObjects = 0;
  
  SwigClassNedPoolingImpl.klass = rb_define_class_under(mOgre, "NedPoolingImpl", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__NedPoolingImpl, (void *) &SwigClassNedPoolingImpl);
  rb_define_alloc_func(SwigClassNedPoolingImpl.klass, _wrap_NedPoolingImpl_allocate);
  rb_define_method(SwigClassNedPoolingImpl.klass, "initialize", VALUEFUNC(_wrap_new_NedPoolingImpl), -1);
  rb_define_singleton_method(SwigClassNedPoolingImpl.klass, "allocBytes", VALUEFUNC(_wrap_NedPoolingImpl_allocBytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingImpl.klass, "deallocBytes", VALUEFUNC(_wrap_NedPoolingImpl_deallocBytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingImpl.klass, "allocBytesAligned", VALUEFUNC(_wrap_NedPoolingImpl_allocBytesAligned), -1);
  rb_define_singleton_method(SwigClassNedPoolingImpl.klass, "deallocBytesAligned", VALUEFUNC(_wrap_NedPoolingImpl_deallocBytesAligned), -1);
  SwigClassNedPoolingImpl.mark = 0;
  SwigClassNedPoolingImpl.destroy = (void (*)(void *)) free_Ogre_NedPoolingImpl;
  SwigClassNedPoolingImpl.trackObjects = 0;
  
  SwigClassNedPoolingPolicy.klass = rb_define_class_under(mOgre, "NedPoolingPolicy", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__NedPoolingPolicy, (void *) &SwigClassNedPoolingPolicy);
  rb_undef_alloc_func(SwigClassNedPoolingPolicy.klass);
  rb_define_singleton_method(SwigClassNedPoolingPolicy.klass, "allocateBytes", VALUEFUNC(_wrap_NedPoolingPolicy_allocateBytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingPolicy.klass, "deallocateBytes", VALUEFUNC(_wrap_NedPoolingPolicy_deallocateBytes), -1);
  rb_define_singleton_method(SwigClassNedPoolingPolicy.klass, "getMaxAllocationSize", VALUEFUNC(_wrap_NedPoolingPolicy_getMaxAllocationSize), -1);
  SwigClassNedPoolingPolicy.mark = 0;
  SwigClassNedPoolingPolicy.destroy = (void (*)(void *)) free_Ogre_NedPoolingPolicy;
  SwigClassNedPoolingPolicy.trackObjects = 0;
  rb_define_const(mOgre, "M_HEADER", SWIG_From_int(static_cast< int >(Ogre::M_HEADER)));
  rb_define_const(mOgre, "M_MESH", SWIG_From_int(static_cast< int >(Ogre::M_MESH)));
  rb_define_const(mOgre, "M_SUBMESH", SWIG_From_int(static_cast< int >(Ogre::M_SUBMESH)));
  rb_define_const(mOgre, "M_SUBMESH_OPERATION", SWIG_From_int(static_cast< int >(Ogre::M_SUBMESH_OPERATION)));
  rb_define_const(mOgre, "M_SUBMESH_BONE_ASSIGNMENT", SWIG_From_int(static_cast< int >(Ogre::M_SUBMESH_BONE_ASSIGNMENT)));
  rb_define_const(mOgre, "M_SUBMESH_TEXTURE_ALIAS", SWIG_From_int(static_cast< int >(Ogre::M_SUBMESH_TEXTURE_ALIAS)));
  rb_define_const(mOgre, "M_GEOMETRY", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY)));
  rb_define_const(mOgre, "M_GEOMETRY_VERTEX_DECLARATION", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY_VERTEX_DECLARATION)));
  rb_define_const(mOgre, "M_GEOMETRY_VERTEX_ELEMENT", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY_VERTEX_ELEMENT)));
  rb_define_const(mOgre, "M_GEOMETRY_VERTEX_BUFFER", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY_VERTEX_BUFFER)));
  rb_define_const(mOgre, "M_GEOMETRY_VERTEX_BUFFER_DATA", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY_VERTEX_BUFFER_DATA)));
  rb_define_const(mOgre, "M_MESH_SKELETON_LINK", SWIG_From_int(static_cast< int >(Ogre::M_MESH_SKELETON_LINK)));
  rb_define_const(mOgre, "M_MESH_BONE_ASSIGNMENT", SWIG_From_int(static_cast< int >(Ogre::M_MESH_BONE_ASSIGNMENT)));
  rb_define_const(mOgre, "M_MESH_LOD", SWIG_From_int(static_cast< int >(Ogre::M_MESH_LOD)));
  rb_define_const(mOgre, "M_MESH_LOD_USAGE", SWIG_From_int(static_cast< int >(Ogre::M_MESH_LOD_USAGE)));
  rb_define_const(mOgre, "M_MESH_LOD_MANUAL", SWIG_From_int(static_cast< int >(Ogre::M_MESH_LOD_MANUAL)));
  rb_define_const(mOgre, "M_MESH_LOD_GENERATED", SWIG_From_int(static_cast< int >(Ogre::M_MESH_LOD_GENERATED)));
  rb_define_const(mOgre, "M_MESH_BOUNDS", SWIG_From_int(static_cast< int >(Ogre::M_MESH_BOUNDS)));
  rb_define_const(mOgre, "M_SUBMESH_NAME_TABLE", SWIG_From_int(static_cast< int >(Ogre::M_SUBMESH_NAME_TABLE)));
  rb_define_const(mOgre, "M_SUBMESH_NAME_TABLE_ELEMENT", SWIG_From_int(static_cast< int >(Ogre::M_SUBMESH_NAME_TABLE_ELEMENT)));
  rb_define_const(mOgre, "M_EDGE_LISTS", SWIG_From_int(static_cast< int >(Ogre::M_EDGE_LISTS)));
  rb_define_const(mOgre, "M_EDGE_LIST_LOD", SWIG_From_int(static_cast< int >(Ogre::M_EDGE_LIST_LOD)));
  rb_define_const(mOgre, "M_EDGE_GROUP", SWIG_From_int(static_cast< int >(Ogre::M_EDGE_GROUP)));
  rb_define_const(mOgre, "M_POSES", SWIG_From_int(static_cast< int >(Ogre::M_POSES)));
  rb_define_const(mOgre, "M_POSE", SWIG_From_int(static_cast< int >(Ogre::M_POSE)));
  rb_define_const(mOgre, "M_POSE_VERTEX", SWIG_From_int(static_cast< int >(Ogre::M_POSE_VERTEX)));
  rb_define_const(mOgre, "M_ANIMATIONS", SWIG_From_int(static_cast< int >(Ogre::M_ANIMATIONS)));
  rb_define_const(mOgre, "M_ANIMATION", SWIG_From_int(static_cast< int >(Ogre::M_ANIMATION)));
  rb_define_const(mOgre, "M_ANIMATION_BASEINFO", SWIG_From_int(static_cast< int >(Ogre::M_ANIMATION_BASEINFO)));
  rb_define_const(mOgre, "M_ANIMATION_TRACK", SWIG_From_int(static_cast< int >(Ogre::M_ANIMATION_TRACK)));
  rb_define_const(mOgre, "M_ANIMATION_MORPH_KEYFRAME", SWIG_From_int(static_cast< int >(Ogre::M_ANIMATION_MORPH_KEYFRAME)));
  rb_define_const(mOgre, "M_ANIMATION_POSE_KEYFRAME", SWIG_From_int(static_cast< int >(Ogre::M_ANIMATION_POSE_KEYFRAME)));
  rb_define_const(mOgre, "M_ANIMATION_POSE_REF", SWIG_From_int(static_cast< int >(Ogre::M_ANIMATION_POSE_REF)));
  rb_define_const(mOgre, "M_TABLE_EXTREMES", SWIG_From_int(static_cast< int >(Ogre::M_TABLE_EXTREMES)));
  rb_define_const(mOgre, "M_GEOMETRY_NORMALS", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY_NORMALS)));
  rb_define_const(mOgre, "M_GEOMETRY_COLOURS", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY_COLOURS)));
  rb_define_const(mOgre, "M_GEOMETRY_TEXCOORDS", SWIG_From_int(static_cast< int >(Ogre::M_GEOMETRY_TEXCOORDS)));
  
  SwigClassPatchSurface.klass = rb_define_class_under(mOgre, "PatchSurface", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PatchSurface, (void *) &SwigClassPatchSurface);
  rb_define_alloc_func(SwigClassPatchSurface.klass, _wrap_PatchSurface_allocate);
  rb_define_method(SwigClassPatchSurface.klass, "initialize", VALUEFUNC(_wrap_new_PatchSurface), -1);
  rb_define_const(SwigClassPatchSurface.klass, "PST_BEZIER", SWIG_From_int(static_cast< int >(Ogre::PatchSurface::PST_BEZIER)));
  rb_define_const(SwigClassPatchSurface.klass, "AUTO_LEVEL", SWIG_From_int(static_cast< int >(Ogre::PatchSurface::AUTO_LEVEL)));
  rb_define_const(SwigClassPatchSurface.klass, "VS_FRONT", SWIG_From_int(static_cast< int >(Ogre::PatchSurface::VS_FRONT)));
  rb_define_const(SwigClassPatchSurface.klass, "VS_BACK", SWIG_From_int(static_cast< int >(Ogre::PatchSurface::VS_BACK)));
  rb_define_const(SwigClassPatchSurface.klass, "VS_BOTH", SWIG_From_int(static_cast< int >(Ogre::PatchSurface::VS_BOTH)));
  rb_define_method(SwigClassPatchSurface.klass, "defineSurface", VALUEFUNC(_wrap_PatchSurface_defineSurface), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getRequiredVertexCount", VALUEFUNC(_wrap_PatchSurface_getRequiredVertexCount), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getRequiredIndexCount", VALUEFUNC(_wrap_PatchSurface_getRequiredIndexCount), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getCurrentIndexCount", VALUEFUNC(_wrap_PatchSurface_getCurrentIndexCount), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getIndexOffset", VALUEFUNC(_wrap_PatchSurface_getIndexOffset), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getVertexOffset", VALUEFUNC(_wrap_PatchSurface_getVertexOffset), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getBounds", VALUEFUNC(_wrap_PatchSurface_getBounds), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getBoundingSphereRadius", VALUEFUNC(_wrap_PatchSurface_getBoundingSphereRadius), -1);
  rb_define_method(SwigClassPatchSurface.klass, "build", VALUEFUNC(_wrap_PatchSurface_build), -1);
  rb_define_method(SwigClassPatchSurface.klass, "setSubdivisionFactor", VALUEFUNC(_wrap_PatchSurface_setSubdivisionFactor), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getSubdivisionFactor", VALUEFUNC(_wrap_PatchSurface_getSubdivisionFactor), -1);
  rb_define_method(SwigClassPatchSurface.klass, "getControlPointBuffer", VALUEFUNC(_wrap_PatchSurface_getControlPointBuffer), -1);
  rb_define_method(SwigClassPatchSurface.klass, "notifyControlPointBufferDeallocated", VALUEFUNC(_wrap_PatchSurface_notifyControlPointBufferDeallocated), -1);
  SwigClassPatchSurface.mark = 0;
  SwigClassPatchSurface.destroy = (void (*)(void *)) free_Ogre_PatchSurface;
  SwigClassPatchSurface.trackObjects = 0;
  
  SwigClassPatchMesh.klass = rb_define_class_under(mOgre, "PatchMesh", ((swig_class *) SWIGTYPE_p_Ogre__Mesh->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PatchMesh, (void *) &SwigClassPatchMesh);
  rb_define_alloc_func(SwigClassPatchMesh.klass, _wrap_PatchMesh_allocate);
  rb_define_method(SwigClassPatchMesh.klass, "initialize", VALUEFUNC(_wrap_new_PatchMesh), -1);
  rb_define_method(SwigClassPatchMesh.klass, "update", VALUEFUNC(_wrap_PatchMesh_update), -1);
  rb_define_method(SwigClassPatchMesh.klass, "define", VALUEFUNC(_wrap_PatchMesh_define), -1);
  rb_define_method(SwigClassPatchMesh.klass, "setSubdivision", VALUEFUNC(_wrap_PatchMesh_setSubdivision), -1);
  SwigClassPatchMesh.mark = 0;
  SwigClassPatchMesh.destroy = (void (*)(void *)) free_Ogre_PatchMesh;
  SwigClassPatchMesh.trackObjects = 0;
  
  SwigClassPatchMeshPtr.klass = rb_define_class_under(mOgre, "PatchMeshPtr", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PatchMeshPtr, (void *) &SwigClassPatchMeshPtr);
  rb_define_alloc_func(SwigClassPatchMeshPtr.klass, _wrap_PatchMeshPtr_allocate);
  rb_define_method(SwigClassPatchMeshPtr.klass, "initialize", VALUEFUNC(_wrap_new_PatchMeshPtr), -1);
  SwigClassPatchMeshPtr.mark = 0;
  SwigClassPatchMeshPtr.destroy = (void (*)(void *)) free_Ogre_PatchMeshPtr;
  SwigClassPatchMeshPtr.trackObjects = 0;
  
  SwigClassMeshManager.klass = rb_define_class_under(mOgre, "MeshManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MeshManager, (void *) &SwigClassMeshManager);
  rb_define_alloc_func(SwigClassMeshManager.klass, _wrap_MeshManager_allocate);
  rb_define_method(SwigClassMeshManager.klass, "initialize", VALUEFUNC(_wrap_new_MeshManager), -1);
  rb_define_method(SwigClassMeshManager.klass, "_initialise", VALUEFUNC(_wrap_MeshManager__initialise), -1);
  rb_define_method(SwigClassMeshManager.klass, "createOrRetrieve", VALUEFUNC(_wrap_MeshManager_createOrRetrieve), -1);
  rb_define_method(SwigClassMeshManager.klass, "prepare", VALUEFUNC(_wrap_MeshManager_prepare), -1);
  rb_define_method(SwigClassMeshManager.klass, "load", VALUEFUNC(_wrap_MeshManager_load), -1);
  rb_define_method(SwigClassMeshManager.klass, "createManual", VALUEFUNC(_wrap_MeshManager_createManual), -1);
  rb_define_method(SwigClassMeshManager.klass, "createPlane", VALUEFUNC(_wrap_MeshManager_createPlane), -1);
  rb_define_method(SwigClassMeshManager.klass, "createCurvedIllusionPlane", VALUEFUNC(_wrap_MeshManager_createCurvedIllusionPlane), -1);
  rb_define_method(SwigClassMeshManager.klass, "createCurvedPlane", VALUEFUNC(_wrap_MeshManager_createCurvedPlane), -1);
  rb_define_method(SwigClassMeshManager.klass, "createBezierPatch", VALUEFUNC(_wrap_MeshManager_createBezierPatch), -1);
  rb_define_method(SwigClassMeshManager.klass, "setPrepareAllMeshesForShadowVolumes", VALUEFUNC(_wrap_MeshManager_setPrepareAllMeshesForShadowVolumes), -1);
  rb_define_method(SwigClassMeshManager.klass, "getPrepareAllMeshesForShadowVolumes", VALUEFUNC(_wrap_MeshManager_getPrepareAllMeshesForShadowVolumes), -1);
  rb_define_singleton_method(SwigClassMeshManager.klass, "getSingleton", VALUEFUNC(_wrap_MeshManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassMeshManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_MeshManager_getSingletonPtr), -1);
  rb_define_method(SwigClassMeshManager.klass, "getBoundsPaddingFactor", VALUEFUNC(_wrap_MeshManager_getBoundsPaddingFactor), -1);
  rb_define_method(SwigClassMeshManager.klass, "setBoundsPaddingFactor", VALUEFUNC(_wrap_MeshManager_setBoundsPaddingFactor), -1);
  rb_define_method(SwigClassMeshManager.klass, "setListener", VALUEFUNC(_wrap_MeshManager_setListener), -1);
  rb_define_method(SwigClassMeshManager.klass, "getListener", VALUEFUNC(_wrap_MeshManager_getListener), -1);
  rb_define_method(SwigClassMeshManager.klass, "loadResource", VALUEFUNC(_wrap_MeshManager_loadResource), -1);
  SwigClassMeshManager.mark = 0;
  SwigClassMeshManager.destroy = (void (*)(void *)) free_Ogre_MeshManager;
  SwigClassMeshManager.trackObjects = 0;
  rb_define_const(mOgre, "MESH_VERSION_LATEST", SWIG_From_int(static_cast< int >(Ogre::MESH_VERSION_LATEST)));
  rb_define_const(mOgre, "MESH_VERSION_1_8", SWIG_From_int(static_cast< int >(Ogre::MESH_VERSION_1_8)));
  rb_define_const(mOgre, "MESH_VERSION_1_7", SWIG_From_int(static_cast< int >(Ogre::MESH_VERSION_1_7)));
  rb_define_const(mOgre, "MESH_VERSION_1_4", SWIG_From_int(static_cast< int >(Ogre::MESH_VERSION_1_4)));
  rb_define_const(mOgre, "MESH_VERSION_1_0", SWIG_From_int(static_cast< int >(Ogre::MESH_VERSION_1_0)));
  rb_define_const(mOgre, "MESH_VERSION_LEGACY", SWIG_From_int(static_cast< int >(Ogre::MESH_VERSION_LEGACY)));
  
  SwigClassMeshSerializer.klass = rb_define_class_under(mOgre, "MeshSerializer", ((swig_class *) SWIGTYPE_p_Ogre__Serializer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MeshSerializer, (void *) &SwigClassMeshSerializer);
  rb_define_alloc_func(SwigClassMeshSerializer.klass, _wrap_MeshSerializer_allocate);
  rb_define_method(SwigClassMeshSerializer.klass, "initialize", VALUEFUNC(_wrap_new_MeshSerializer), -1);
  rb_define_method(SwigClassMeshSerializer.klass, "exportMesh", VALUEFUNC(_wrap_MeshSerializer_exportMesh), -1);
  rb_define_method(SwigClassMeshSerializer.klass, "importMesh", VALUEFUNC(_wrap_MeshSerializer_importMesh), -1);
  rb_define_method(SwigClassMeshSerializer.klass, "setListener", VALUEFUNC(_wrap_MeshSerializer_setListener), -1);
  rb_define_method(SwigClassMeshSerializer.klass, "getListener", VALUEFUNC(_wrap_MeshSerializer_getListener), -1);
  SwigClassMeshSerializer.mark = 0;
  SwigClassMeshSerializer.destroy = (void (*)(void *)) free_Ogre_MeshSerializer;
  SwigClassMeshSerializer.trackObjects = 0;
  
  SwigClassMeshSerializerListener.klass = rb_define_class_under(mOgre, "MeshSerializerListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MeshSerializerListener, (void *) &SwigClassMeshSerializerListener);
  rb_undef_alloc_func(SwigClassMeshSerializerListener.klass);
  rb_define_method(SwigClassMeshSerializerListener.klass, "processMaterialName", VALUEFUNC(_wrap_MeshSerializerListener_processMaterialName), -1);
  rb_define_method(SwigClassMeshSerializerListener.klass, "processSkeletonName", VALUEFUNC(_wrap_MeshSerializerListener_processSkeletonName), -1);
  SwigClassMeshSerializerListener.mark = 0;
  SwigClassMeshSerializerListener.destroy = (void (*)(void *)) free_Ogre_MeshSerializerListener;
  SwigClassMeshSerializerListener.trackObjects = 0;
  
  SwigClassOptimisedUtil.klass = rb_define_class_under(mOgre, "OptimisedUtil", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OptimisedUtil, (void *) &SwigClassOptimisedUtil);
  rb_undef_alloc_func(SwigClassOptimisedUtil.klass);
  rb_define_singleton_method(SwigClassOptimisedUtil.klass, "getImplementation", VALUEFUNC(_wrap_OptimisedUtil_getImplementation), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "softwareVertexSkinning", VALUEFUNC(_wrap_OptimisedUtil_softwareVertexSkinning), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "softwareVertexMorph", VALUEFUNC(_wrap_OptimisedUtil_softwareVertexMorph), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "concatenateAffineMatrices", VALUEFUNC(_wrap_OptimisedUtil_concatenateAffineMatrices), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "calculateFaceNormals", VALUEFUNC(_wrap_OptimisedUtil_calculateFaceNormals), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "calculateLightFacing", VALUEFUNC(_wrap_OptimisedUtil_calculateLightFacing), -1);
  rb_define_method(SwigClassOptimisedUtil.klass, "extrudeVertices", VALUEFUNC(_wrap_OptimisedUtil_extrudeVertices), -1);
  SwigClassOptimisedUtil.mark = 0;
  SwigClassOptimisedUtil.destroy = (void (*)(void *)) free_Ogre_OptimisedUtil;
  SwigClassOptimisedUtil.trackObjects = 0;
  
  SwigClassOverlay.klass = rb_define_class_under(mOgre, "Overlay", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Overlay, (void *) &SwigClassOverlay);
  rb_define_alloc_func(SwigClassOverlay.klass, _wrap_Overlay_allocate);
  rb_define_method(SwigClassOverlay.klass, "initialize", VALUEFUNC(_wrap_new_Overlay), -1);
  rb_define_method(SwigClassOverlay.klass, "getChild", VALUEFUNC(_wrap_Overlay_getChild), -1);
  rb_define_method(SwigClassOverlay.klass, "getName", VALUEFUNC(_wrap_Overlay_getName), -1);
  rb_define_method(SwigClassOverlay.klass, "setZOrder", VALUEFUNC(_wrap_Overlay_setZOrder), -1);
  rb_define_method(SwigClassOverlay.klass, "getZOrder", VALUEFUNC(_wrap_Overlay_getZOrder), -1);
  rb_define_method(SwigClassOverlay.klass, "isVisible", VALUEFUNC(_wrap_Overlay_isVisible), -1);
  rb_define_method(SwigClassOverlay.klass, "isInitialised", VALUEFUNC(_wrap_Overlay_isInitialised), -1);
  rb_define_method(SwigClassOverlay.klass, "show", VALUEFUNC(_wrap_Overlay_show), -1);
  rb_define_method(SwigClassOverlay.klass, "hide", VALUEFUNC(_wrap_Overlay_hide), -1);
  rb_define_method(SwigClassOverlay.klass, "add2D", VALUEFUNC(_wrap_Overlay_add2D), -1);
  rb_define_method(SwigClassOverlay.klass, "remove2D", VALUEFUNC(_wrap_Overlay_remove2D), -1);
  rb_define_method(SwigClassOverlay.klass, "add3D", VALUEFUNC(_wrap_Overlay_add3D), -1);
  rb_define_method(SwigClassOverlay.klass, "remove3D", VALUEFUNC(_wrap_Overlay_remove3D), -1);
  rb_define_method(SwigClassOverlay.klass, "clear", VALUEFUNC(_wrap_Overlay_clear), -1);
  rb_define_method(SwigClassOverlay.klass, "setScroll", VALUEFUNC(_wrap_Overlay_setScroll), -1);
  rb_define_method(SwigClassOverlay.klass, "getScrollX", VALUEFUNC(_wrap_Overlay_getScrollX), -1);
  rb_define_method(SwigClassOverlay.klass, "getScrollY", VALUEFUNC(_wrap_Overlay_getScrollY), -1);
  rb_define_method(SwigClassOverlay.klass, "scroll", VALUEFUNC(_wrap_Overlay_scroll), -1);
  rb_define_method(SwigClassOverlay.klass, "setRotate", VALUEFUNC(_wrap_Overlay_setRotate), -1);
  rb_define_method(SwigClassOverlay.klass, "getRotate", VALUEFUNC(_wrap_Overlay_getRotate), -1);
  rb_define_method(SwigClassOverlay.klass, "rotate", VALUEFUNC(_wrap_Overlay_rotate), -1);
  rb_define_method(SwigClassOverlay.klass, "setScale", VALUEFUNC(_wrap_Overlay_setScale), -1);
  rb_define_method(SwigClassOverlay.klass, "getScaleX", VALUEFUNC(_wrap_Overlay_getScaleX), -1);
  rb_define_method(SwigClassOverlay.klass, "getScaleY", VALUEFUNC(_wrap_Overlay_getScaleY), -1);
  rb_define_method(SwigClassOverlay.klass, "_getWorldTransforms", VALUEFUNC(_wrap_Overlay__getWorldTransforms), -1);
  rb_define_method(SwigClassOverlay.klass, "_findVisibleObjects", VALUEFUNC(_wrap_Overlay__findVisibleObjects), -1);
  rb_define_method(SwigClassOverlay.klass, "findElementAt", VALUEFUNC(_wrap_Overlay_findElementAt), -1);
  rb_define_method(SwigClassOverlay.klass, "get2DElementsIterator", VALUEFUNC(_wrap_Overlay_get2DElementsIterator), -1);
  rb_define_method(SwigClassOverlay.klass, "getOrigin", VALUEFUNC(_wrap_Overlay_getOrigin), -1);
  rb_define_method(SwigClassOverlay.klass, "_notifyOrigin", VALUEFUNC(_wrap_Overlay__notifyOrigin), -1);
  SwigClassOverlay.mark = 0;
  SwigClassOverlay.destroy = (void (*)(void *)) free_Ogre_Overlay;
  SwigClassOverlay.trackObjects = 0;
  
  SwigClassTextAreaOverlayElement.klass = rb_define_class_under(mOgre, "TextAreaOverlayElement", ((swig_class *) SWIGTYPE_p_Ogre__OverlayElement->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TextAreaOverlayElement, (void *) &SwigClassTextAreaOverlayElement);
  rb_define_alloc_func(SwigClassTextAreaOverlayElement.klass, _wrap_TextAreaOverlayElement_allocate);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "initialize", VALUEFUNC(_wrap_new_TextAreaOverlayElement), -1);
  rb_define_const(SwigClassTextAreaOverlayElement.klass, "Left", SWIG_From_int(static_cast< int >(Ogre::TextAreaOverlayElement::Left)));
  rb_define_const(SwigClassTextAreaOverlayElement.klass, "Right", SWIG_From_int(static_cast< int >(Ogre::TextAreaOverlayElement::Right)));
  rb_define_const(SwigClassTextAreaOverlayElement.klass, "Center", SWIG_From_int(static_cast< int >(Ogre::TextAreaOverlayElement::Center)));
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "initialise", VALUEFUNC(_wrap_TextAreaOverlayElement_initialise), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setCaption", VALUEFUNC(_wrap_TextAreaOverlayElement_setCaption), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setCharHeight", VALUEFUNC(_wrap_TextAreaOverlayElement_setCharHeight), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getCharHeight", VALUEFUNC(_wrap_TextAreaOverlayElement_getCharHeight), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setSpaceWidth", VALUEFUNC(_wrap_TextAreaOverlayElement_setSpaceWidth), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getSpaceWidth", VALUEFUNC(_wrap_TextAreaOverlayElement_getSpaceWidth), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setFontName", VALUEFUNC(_wrap_TextAreaOverlayElement_setFontName), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getFontName", VALUEFUNC(_wrap_TextAreaOverlayElement_getFontName), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getTypeName", VALUEFUNC(_wrap_TextAreaOverlayElement_getTypeName), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getMaterial", VALUEFUNC(_wrap_TextAreaOverlayElement_getMaterial), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getRenderOperation", VALUEFUNC(_wrap_TextAreaOverlayElement_getRenderOperation), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setMaterialName", VALUEFUNC(_wrap_TextAreaOverlayElement_setMaterialName), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setColour", VALUEFUNC(_wrap_TextAreaOverlayElement_setColour), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getColour", VALUEFUNC(_wrap_TextAreaOverlayElement_getColour), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setColourBottom", VALUEFUNC(_wrap_TextAreaOverlayElement_setColourBottom), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getColourBottom", VALUEFUNC(_wrap_TextAreaOverlayElement_getColourBottom), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setColourTop", VALUEFUNC(_wrap_TextAreaOverlayElement_setColourTop), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getColourTop", VALUEFUNC(_wrap_TextAreaOverlayElement_getColourTop), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setAlignment", VALUEFUNC(_wrap_TextAreaOverlayElement_setAlignment), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "getAlignment", VALUEFUNC(_wrap_TextAreaOverlayElement_getAlignment), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "setMetricsMode", VALUEFUNC(_wrap_TextAreaOverlayElement_setMetricsMode), -1);
  rb_define_method(SwigClassTextAreaOverlayElement.klass, "_update", VALUEFUNC(_wrap_TextAreaOverlayElement__update), -1);
  SwigClassTextAreaOverlayElement.mark = 0;
  SwigClassTextAreaOverlayElement.destroy = (void (*)(void *)) free_Ogre_TextAreaOverlayElement;
  SwigClassTextAreaOverlayElement.trackObjects = 0;
  
  SwigClassOverlayElementFactory.klass = rb_define_class_under(mOgre, "OverlayElementFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayElementFactory, (void *) &SwigClassOverlayElementFactory);
  rb_undef_alloc_func(SwigClassOverlayElementFactory.klass);
  rb_define_method(SwigClassOverlayElementFactory.klass, "createOverlayElement", VALUEFUNC(_wrap_OverlayElementFactory_createOverlayElement), -1);
  rb_define_method(SwigClassOverlayElementFactory.klass, "destroyOverlayElement", VALUEFUNC(_wrap_OverlayElementFactory_destroyOverlayElement), -1);
  rb_define_method(SwigClassOverlayElementFactory.klass, "getTypeName", VALUEFUNC(_wrap_OverlayElementFactory_getTypeName), -1);
  SwigClassOverlayElementFactory.mark = 0;
  SwigClassOverlayElementFactory.destroy = (void (*)(void *)) free_Ogre_OverlayElementFactory;
  SwigClassOverlayElementFactory.trackObjects = 0;
  
  SwigClassPanelOverlayElementFactory.klass = rb_define_class_under(mOgre, "PanelOverlayElementFactory", ((swig_class *) SWIGTYPE_p_Ogre__OverlayElementFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PanelOverlayElementFactory, (void *) &SwigClassPanelOverlayElementFactory);
  rb_define_alloc_func(SwigClassPanelOverlayElementFactory.klass, _wrap_PanelOverlayElementFactory_allocate);
  rb_define_method(SwigClassPanelOverlayElementFactory.klass, "initialize", VALUEFUNC(_wrap_new_PanelOverlayElementFactory), -1);
  rb_define_method(SwigClassPanelOverlayElementFactory.klass, "createOverlayElement", VALUEFUNC(_wrap_PanelOverlayElementFactory_createOverlayElement), -1);
  rb_define_method(SwigClassPanelOverlayElementFactory.klass, "getTypeName", VALUEFUNC(_wrap_PanelOverlayElementFactory_getTypeName), -1);
  SwigClassPanelOverlayElementFactory.mark = 0;
  SwigClassPanelOverlayElementFactory.destroy = (void (*)(void *)) free_Ogre_PanelOverlayElementFactory;
  SwigClassPanelOverlayElementFactory.trackObjects = 0;
  
  SwigClassBorderPanelOverlayElementFactory.klass = rb_define_class_under(mOgre, "BorderPanelOverlayElementFactory", ((swig_class *) SWIGTYPE_p_Ogre__OverlayElementFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BorderPanelOverlayElementFactory, (void *) &SwigClassBorderPanelOverlayElementFactory);
  rb_define_alloc_func(SwigClassBorderPanelOverlayElementFactory.klass, _wrap_BorderPanelOverlayElementFactory_allocate);
  rb_define_method(SwigClassBorderPanelOverlayElementFactory.klass, "initialize", VALUEFUNC(_wrap_new_BorderPanelOverlayElementFactory), -1);
  rb_define_method(SwigClassBorderPanelOverlayElementFactory.klass, "createOverlayElement", VALUEFUNC(_wrap_BorderPanelOverlayElementFactory_createOverlayElement), -1);
  rb_define_method(SwigClassBorderPanelOverlayElementFactory.klass, "getTypeName", VALUEFUNC(_wrap_BorderPanelOverlayElementFactory_getTypeName), -1);
  SwigClassBorderPanelOverlayElementFactory.mark = 0;
  SwigClassBorderPanelOverlayElementFactory.destroy = (void (*)(void *)) free_Ogre_BorderPanelOverlayElementFactory;
  SwigClassBorderPanelOverlayElementFactory.trackObjects = 0;
  
  SwigClassTextAreaOverlayElementFactory.klass = rb_define_class_under(mOgre, "TextAreaOverlayElementFactory", ((swig_class *) SWIGTYPE_p_Ogre__OverlayElementFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TextAreaOverlayElementFactory, (void *) &SwigClassTextAreaOverlayElementFactory);
  rb_define_alloc_func(SwigClassTextAreaOverlayElementFactory.klass, _wrap_TextAreaOverlayElementFactory_allocate);
  rb_define_method(SwigClassTextAreaOverlayElementFactory.klass, "initialize", VALUEFUNC(_wrap_new_TextAreaOverlayElementFactory), -1);
  rb_define_method(SwigClassTextAreaOverlayElementFactory.klass, "createOverlayElement", VALUEFUNC(_wrap_TextAreaOverlayElementFactory_createOverlayElement), -1);
  rb_define_method(SwigClassTextAreaOverlayElementFactory.klass, "getTypeName", VALUEFUNC(_wrap_TextAreaOverlayElementFactory_getTypeName), -1);
  SwigClassTextAreaOverlayElementFactory.mark = 0;
  SwigClassTextAreaOverlayElementFactory.destroy = (void (*)(void *)) free_Ogre_TextAreaOverlayElementFactory;
  SwigClassTextAreaOverlayElementFactory.trackObjects = 0;
  
  SwigClassOverlayManager.klass = rb_define_class_under(mOgre, "OverlayManager", ((swig_class *) SWIGTYPE_p_Ogre__ScriptLoader->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__OverlayManager, (void *) &SwigClassOverlayManager);
  rb_define_alloc_func(SwigClassOverlayManager.klass, _wrap_OverlayManager_allocate);
  rb_define_method(SwigClassOverlayManager.klass, "initialize", VALUEFUNC(_wrap_new_OverlayManager), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getScriptPatterns", VALUEFUNC(_wrap_OverlayManager_getScriptPatterns), -1);
  rb_define_method(SwigClassOverlayManager.klass, "parseScript", VALUEFUNC(_wrap_OverlayManager_parseScript), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getLoadingOrder", VALUEFUNC(_wrap_OverlayManager_getLoadingOrder), -1);
  rb_define_method(SwigClassOverlayManager.klass, "create", VALUEFUNC(_wrap_OverlayManager_create), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getByName", VALUEFUNC(_wrap_OverlayManager_getByName), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroy", VALUEFUNC(_wrap_OverlayManager_destroy), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroyAll", VALUEFUNC(_wrap_OverlayManager_destroyAll), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getOverlayIterator", VALUEFUNC(_wrap_OverlayManager_getOverlayIterator), -1);
  rb_define_method(SwigClassOverlayManager.klass, "_queueOverlaysForRendering", VALUEFUNC(_wrap_OverlayManager__queueOverlaysForRendering), -1);
  rb_define_method(SwigClassOverlayManager.klass, "hasViewportChanged", VALUEFUNC(_wrap_OverlayManager_hasViewportChanged), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getViewportHeight", VALUEFUNC(_wrap_OverlayManager_getViewportHeight), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getViewportWidth", VALUEFUNC(_wrap_OverlayManager_getViewportWidth), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getViewportAspectRatio", VALUEFUNC(_wrap_OverlayManager_getViewportAspectRatio), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getViewportOrientationMode", VALUEFUNC(_wrap_OverlayManager_getViewportOrientationMode), -1);
  rb_define_method(SwigClassOverlayManager.klass, "createOverlayElement", VALUEFUNC(_wrap_OverlayManager_createOverlayElement), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getOverlayElement", VALUEFUNC(_wrap_OverlayManager_getOverlayElement), -1);
  rb_define_method(SwigClassOverlayManager.klass, "hasOverlayElement", VALUEFUNC(_wrap_OverlayManager_hasOverlayElement), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroyOverlayElement", VALUEFUNC(_wrap_OverlayManager_destroyOverlayElement), -1);
  rb_define_method(SwigClassOverlayManager.klass, "destroyAllOverlayElements", VALUEFUNC(_wrap_OverlayManager_destroyAllOverlayElements), -1);
  rb_define_method(SwigClassOverlayManager.klass, "addOverlayElementFactory", VALUEFUNC(_wrap_OverlayManager_addOverlayElementFactory), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getOverlayElementFactoryMap", VALUEFUNC(_wrap_OverlayManager_getOverlayElementFactoryMap), -1);
  rb_define_method(SwigClassOverlayManager.klass, "createOverlayElementFromTemplate", VALUEFUNC(_wrap_OverlayManager_createOverlayElementFromTemplate), -1);
  rb_define_method(SwigClassOverlayManager.klass, "cloneOverlayElementFromTemplate", VALUEFUNC(_wrap_OverlayManager_cloneOverlayElementFromTemplate), -1);
  rb_define_method(SwigClassOverlayManager.klass, "createOverlayElementFromFactory", VALUEFUNC(_wrap_OverlayManager_createOverlayElementFromFactory), -1);
  rb_define_method(SwigClassOverlayManager.klass, "getTemplateIterator", VALUEFUNC(_wrap_OverlayManager_getTemplateIterator), -1);
  rb_define_method(SwigClassOverlayManager.klass, "isTemplate", VALUEFUNC(_wrap_OverlayManager_isTemplate), -1);
  rb_define_singleton_method(SwigClassOverlayManager.klass, "getSingleton", VALUEFUNC(_wrap_OverlayManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassOverlayManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_OverlayManager_getSingletonPtr), -1);
  SwigClassOverlayManager.mark = 0;
  SwigClassOverlayManager.destroy = (void (*)(void *)) debug_free_OverlayManager;
  SwigClassOverlayManager.trackObjects = 0;
  
  SwigClassParticleVisualData.klass = rb_define_class_under(mOgre, "ParticleVisualData", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleVisualData, (void *) &SwigClassParticleVisualData);
  rb_define_alloc_func(SwigClassParticleVisualData.klass, _wrap_ParticleVisualData_allocate);
  rb_define_method(SwigClassParticleVisualData.klass, "initialize", VALUEFUNC(_wrap_new_ParticleVisualData), -1);
  SwigClassParticleVisualData.mark = 0;
  SwigClassParticleVisualData.destroy = (void (*)(void *)) free_Ogre_ParticleVisualData;
  SwigClassParticleVisualData.trackObjects = 0;
  
  SwigClassParticle.klass = rb_define_class_under(mOgre, "Particle", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Particle, (void *) &SwigClassParticle);
  rb_define_alloc_func(SwigClassParticle.klass, _wrap_Particle_allocate);
  rb_define_method(SwigClassParticle.klass, "initialize", VALUEFUNC(_wrap_new_Particle), -1);
  rb_define_const(SwigClassParticle.klass, "Visual", SWIG_From_int(static_cast< int >(Ogre::Particle::Visual)));
  rb_define_const(SwigClassParticle.klass, "Emitter", SWIG_From_int(static_cast< int >(Ogre::Particle::Emitter)));
  rb_define_method(SwigClassParticle.klass, "mOwnDimensions=", VALUEFUNC(_wrap_Particle_mOwnDimensions_set), -1);
  rb_define_method(SwigClassParticle.klass, "mOwnDimensions", VALUEFUNC(_wrap_Particle_mOwnDimensions_get), -1);
  rb_define_method(SwigClassParticle.klass, "mWidth=", VALUEFUNC(_wrap_Particle_mWidth_set), -1);
  rb_define_method(SwigClassParticle.klass, "mWidth", VALUEFUNC(_wrap_Particle_mWidth_get), -1);
  rb_define_method(SwigClassParticle.klass, "mHeight=", VALUEFUNC(_wrap_Particle_mHeight_set), -1);
  rb_define_method(SwigClassParticle.klass, "mHeight", VALUEFUNC(_wrap_Particle_mHeight_get), -1);
  rb_define_method(SwigClassParticle.klass, "rotation=", VALUEFUNC(_wrap_Particle_rotation_set), -1);
  rb_define_method(SwigClassParticle.klass, "rotation", VALUEFUNC(_wrap_Particle_rotation_get), -1);
  rb_define_method(SwigClassParticle.klass, "position=", VALUEFUNC(_wrap_Particle_position_set), -1);
  rb_define_method(SwigClassParticle.klass, "position", VALUEFUNC(_wrap_Particle_position_get), -1);
  rb_define_method(SwigClassParticle.klass, "direction=", VALUEFUNC(_wrap_Particle_direction_set), -1);
  rb_define_method(SwigClassParticle.klass, "direction", VALUEFUNC(_wrap_Particle_direction_get), -1);
  rb_define_method(SwigClassParticle.klass, "colour=", VALUEFUNC(_wrap_Particle_colour_set), -1);
  rb_define_method(SwigClassParticle.klass, "colour", VALUEFUNC(_wrap_Particle_colour_get), -1);
  rb_define_method(SwigClassParticle.klass, "timeToLive=", VALUEFUNC(_wrap_Particle_timeToLive_set), -1);
  rb_define_method(SwigClassParticle.klass, "timeToLive", VALUEFUNC(_wrap_Particle_timeToLive_get), -1);
  rb_define_method(SwigClassParticle.klass, "totalTimeToLive=", VALUEFUNC(_wrap_Particle_totalTimeToLive_set), -1);
  rb_define_method(SwigClassParticle.klass, "totalTimeToLive", VALUEFUNC(_wrap_Particle_totalTimeToLive_get), -1);
  rb_define_method(SwigClassParticle.klass, "rotationSpeed=", VALUEFUNC(_wrap_Particle_rotationSpeed_set), -1);
  rb_define_method(SwigClassParticle.klass, "rotationSpeed", VALUEFUNC(_wrap_Particle_rotationSpeed_get), -1);
  rb_define_method(SwigClassParticle.klass, "particleType=", VALUEFUNC(_wrap_Particle_particleType_set), -1);
  rb_define_method(SwigClassParticle.klass, "particleType", VALUEFUNC(_wrap_Particle_particleType_get), -1);
  rb_define_method(SwigClassParticle.klass, "setDimensions", VALUEFUNC(_wrap_Particle_setDimensions), -1);
  rb_define_method(SwigClassParticle.klass, "hasOwnDimensions", VALUEFUNC(_wrap_Particle_hasOwnDimensions), -1);
  rb_define_method(SwigClassParticle.klass, "getOwnWidth", VALUEFUNC(_wrap_Particle_getOwnWidth), -1);
  rb_define_method(SwigClassParticle.klass, "getOwnHeight", VALUEFUNC(_wrap_Particle_getOwnHeight), -1);
  rb_define_method(SwigClassParticle.klass, "setRotation", VALUEFUNC(_wrap_Particle_setRotation), -1);
  rb_define_method(SwigClassParticle.klass, "getRotation", VALUEFUNC(_wrap_Particle_getRotation), -1);
  rb_define_method(SwigClassParticle.klass, "_notifyOwner", VALUEFUNC(_wrap_Particle__notifyOwner), -1);
  rb_define_method(SwigClassParticle.klass, "_notifyVisualData", VALUEFUNC(_wrap_Particle__notifyVisualData), -1);
  rb_define_method(SwigClassParticle.klass, "getVisualData", VALUEFUNC(_wrap_Particle_getVisualData), -1);
  rb_define_method(SwigClassParticle.klass, "resetDimensions", VALUEFUNC(_wrap_Particle_resetDimensions), -1);
  SwigClassParticle.mark = 0;
  SwigClassParticle.destroy = (void (*)(void *)) free_Ogre_Particle;
  SwigClassParticle.trackObjects = 0;
  
  SwigClassParticleAffector.klass = rb_define_class_under(mOgre, "ParticleAffector", ((swig_class *) SWIGTYPE_p_Ogre__StringInterface->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleAffector, (void *) &SwigClassParticleAffector);
  rb_undef_alloc_func(SwigClassParticleAffector.klass);
  rb_define_method(SwigClassParticleAffector.klass, "_initParticle", VALUEFUNC(_wrap_ParticleAffector__initParticle), -1);
  rb_define_method(SwigClassParticleAffector.klass, "_affectParticles", VALUEFUNC(_wrap_ParticleAffector__affectParticles), -1);
  rb_define_method(SwigClassParticleAffector.klass, "getType", VALUEFUNC(_wrap_ParticleAffector_getType), -1);
  SwigClassParticleAffector.mark = 0;
  SwigClassParticleAffector.destroy = (void (*)(void *)) free_Ogre_ParticleAffector;
  SwigClassParticleAffector.trackObjects = 0;
  
  SwigClassParticleAffectorFactory.klass = rb_define_class_under(mOgre, "ParticleAffectorFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleAffectorFactory, (void *) &SwigClassParticleAffectorFactory);
  rb_undef_alloc_func(SwigClassParticleAffectorFactory.klass);
  rb_define_method(SwigClassParticleAffectorFactory.klass, "getName", VALUEFUNC(_wrap_ParticleAffectorFactory_getName), -1);
  rb_define_method(SwigClassParticleAffectorFactory.klass, "createAffector", VALUEFUNC(_wrap_ParticleAffectorFactory_createAffector), -1);
  rb_define_method(SwigClassParticleAffectorFactory.klass, "destroyAffector", VALUEFUNC(_wrap_ParticleAffectorFactory_destroyAffector), -1);
  SwigClassParticleAffectorFactory.mark = 0;
  SwigClassParticleAffectorFactory.destroy = (void (*)(void *)) free_Ogre_ParticleAffectorFactory;
  SwigClassParticleAffectorFactory.trackObjects = 0;
  
  SwigClassCmdAngle.klass = rb_define_class_under(mOgre, "CmdAngle", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdAngle, (void *) &SwigClassCmdAngle);
  rb_define_alloc_func(SwigClassCmdAngle.klass, _wrap_CmdAngle_allocate);
  rb_define_method(SwigClassCmdAngle.klass, "initialize", VALUEFUNC(_wrap_new_CmdAngle), -1);
  rb_define_method(SwigClassCmdAngle.klass, "doGet", VALUEFUNC(_wrap_CmdAngle_doGet), -1);
  rb_define_method(SwigClassCmdAngle.klass, "doSet", VALUEFUNC(_wrap_CmdAngle_doSet), -1);
  SwigClassCmdAngle.mark = 0;
  SwigClassCmdAngle.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdAngle;
  SwigClassCmdAngle.trackObjects = 0;
  
  SwigClassCmdColour.klass = rb_define_class_under(mOgre, "CmdColour", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdColour, (void *) &SwigClassCmdColour);
  rb_define_alloc_func(SwigClassCmdColour.klass, _wrap_CmdColour_allocate);
  rb_define_method(SwigClassCmdColour.klass, "initialize", VALUEFUNC(_wrap_new_CmdColour), -1);
  rb_define_method(SwigClassCmdColour.klass, "doGet", VALUEFUNC(_wrap_CmdColour_doGet), -1);
  rb_define_method(SwigClassCmdColour.klass, "doSet", VALUEFUNC(_wrap_CmdColour_doSet), -1);
  SwigClassCmdColour.mark = 0;
  SwigClassCmdColour.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdColour;
  SwigClassCmdColour.trackObjects = 0;
  
  SwigClassCmdColourRangeStart.klass = rb_define_class_under(mOgre, "CmdColourRangeStart", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdColourRangeStart, (void *) &SwigClassCmdColourRangeStart);
  rb_define_alloc_func(SwigClassCmdColourRangeStart.klass, _wrap_CmdColourRangeStart_allocate);
  rb_define_method(SwigClassCmdColourRangeStart.klass, "initialize", VALUEFUNC(_wrap_new_CmdColourRangeStart), -1);
  rb_define_method(SwigClassCmdColourRangeStart.klass, "doGet", VALUEFUNC(_wrap_CmdColourRangeStart_doGet), -1);
  rb_define_method(SwigClassCmdColourRangeStart.klass, "doSet", VALUEFUNC(_wrap_CmdColourRangeStart_doSet), -1);
  SwigClassCmdColourRangeStart.mark = 0;
  SwigClassCmdColourRangeStart.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdColourRangeStart;
  SwigClassCmdColourRangeStart.trackObjects = 0;
  
  SwigClassCmdColourRangeEnd.klass = rb_define_class_under(mOgre, "CmdColourRangeEnd", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdColourRangeEnd, (void *) &SwigClassCmdColourRangeEnd);
  rb_define_alloc_func(SwigClassCmdColourRangeEnd.klass, _wrap_CmdColourRangeEnd_allocate);
  rb_define_method(SwigClassCmdColourRangeEnd.klass, "initialize", VALUEFUNC(_wrap_new_CmdColourRangeEnd), -1);
  rb_define_method(SwigClassCmdColourRangeEnd.klass, "doGet", VALUEFUNC(_wrap_CmdColourRangeEnd_doGet), -1);
  rb_define_method(SwigClassCmdColourRangeEnd.klass, "doSet", VALUEFUNC(_wrap_CmdColourRangeEnd_doSet), -1);
  SwigClassCmdColourRangeEnd.mark = 0;
  SwigClassCmdColourRangeEnd.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdColourRangeEnd;
  SwigClassCmdColourRangeEnd.trackObjects = 0;
  
  SwigClassCmdDirection.klass = rb_define_class_under(mOgre, "CmdDirection", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdDirection, (void *) &SwigClassCmdDirection);
  rb_define_alloc_func(SwigClassCmdDirection.klass, _wrap_CmdDirection_allocate);
  rb_define_method(SwigClassCmdDirection.klass, "initialize", VALUEFUNC(_wrap_new_CmdDirection), -1);
  rb_define_method(SwigClassCmdDirection.klass, "doGet", VALUEFUNC(_wrap_CmdDirection_doGet), -1);
  rb_define_method(SwigClassCmdDirection.klass, "doSet", VALUEFUNC(_wrap_CmdDirection_doSet), -1);
  SwigClassCmdDirection.mark = 0;
  SwigClassCmdDirection.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdDirection;
  SwigClassCmdDirection.trackObjects = 0;
  
  SwigClassCmdUp.klass = rb_define_class_under(mOgre, "CmdUp", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdUp, (void *) &SwigClassCmdUp);
  rb_define_alloc_func(SwigClassCmdUp.klass, _wrap_CmdUp_allocate);
  rb_define_method(SwigClassCmdUp.klass, "initialize", VALUEFUNC(_wrap_new_CmdUp), -1);
  rb_define_method(SwigClassCmdUp.klass, "doGet", VALUEFUNC(_wrap_CmdUp_doGet), -1);
  rb_define_method(SwigClassCmdUp.klass, "doSet", VALUEFUNC(_wrap_CmdUp_doSet), -1);
  SwigClassCmdUp.mark = 0;
  SwigClassCmdUp.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdUp;
  SwigClassCmdUp.trackObjects = 0;
  
  SwigClassCmdEmissionRate.klass = rb_define_class_under(mOgre, "CmdEmissionRate", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdEmissionRate, (void *) &SwigClassCmdEmissionRate);
  rb_define_alloc_func(SwigClassCmdEmissionRate.klass, _wrap_CmdEmissionRate_allocate);
  rb_define_method(SwigClassCmdEmissionRate.klass, "initialize", VALUEFUNC(_wrap_new_CmdEmissionRate), -1);
  rb_define_method(SwigClassCmdEmissionRate.klass, "doGet", VALUEFUNC(_wrap_CmdEmissionRate_doGet), -1);
  rb_define_method(SwigClassCmdEmissionRate.klass, "doSet", VALUEFUNC(_wrap_CmdEmissionRate_doSet), -1);
  SwigClassCmdEmissionRate.mark = 0;
  SwigClassCmdEmissionRate.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdEmissionRate;
  SwigClassCmdEmissionRate.trackObjects = 0;
  
  SwigClassCmdVelocity.klass = rb_define_class_under(mOgre, "CmdVelocity", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdVelocity, (void *) &SwigClassCmdVelocity);
  rb_define_alloc_func(SwigClassCmdVelocity.klass, _wrap_CmdVelocity_allocate);
  rb_define_method(SwigClassCmdVelocity.klass, "initialize", VALUEFUNC(_wrap_new_CmdVelocity), -1);
  rb_define_method(SwigClassCmdVelocity.klass, "doGet", VALUEFUNC(_wrap_CmdVelocity_doGet), -1);
  rb_define_method(SwigClassCmdVelocity.klass, "doSet", VALUEFUNC(_wrap_CmdVelocity_doSet), -1);
  SwigClassCmdVelocity.mark = 0;
  SwigClassCmdVelocity.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdVelocity;
  SwigClassCmdVelocity.trackObjects = 0;
  
  SwigClassCmdMinVelocity.klass = rb_define_class_under(mOgre, "CmdMinVelocity", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMinVelocity, (void *) &SwigClassCmdMinVelocity);
  rb_define_alloc_func(SwigClassCmdMinVelocity.klass, _wrap_CmdMinVelocity_allocate);
  rb_define_method(SwigClassCmdMinVelocity.klass, "initialize", VALUEFUNC(_wrap_new_CmdMinVelocity), -1);
  rb_define_method(SwigClassCmdMinVelocity.klass, "doGet", VALUEFUNC(_wrap_CmdMinVelocity_doGet), -1);
  rb_define_method(SwigClassCmdMinVelocity.klass, "doSet", VALUEFUNC(_wrap_CmdMinVelocity_doSet), -1);
  SwigClassCmdMinVelocity.mark = 0;
  SwigClassCmdMinVelocity.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMinVelocity;
  SwigClassCmdMinVelocity.trackObjects = 0;
  
  SwigClassCmdMaxVelocity.klass = rb_define_class_under(mOgre, "CmdMaxVelocity", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxVelocity, (void *) &SwigClassCmdMaxVelocity);
  rb_define_alloc_func(SwigClassCmdMaxVelocity.klass, _wrap_CmdMaxVelocity_allocate);
  rb_define_method(SwigClassCmdMaxVelocity.klass, "initialize", VALUEFUNC(_wrap_new_CmdMaxVelocity), -1);
  rb_define_method(SwigClassCmdMaxVelocity.klass, "doGet", VALUEFUNC(_wrap_CmdMaxVelocity_doGet), -1);
  rb_define_method(SwigClassCmdMaxVelocity.klass, "doSet", VALUEFUNC(_wrap_CmdMaxVelocity_doSet), -1);
  SwigClassCmdMaxVelocity.mark = 0;
  SwigClassCmdMaxVelocity.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMaxVelocity;
  SwigClassCmdMaxVelocity.trackObjects = 0;
  
  SwigClassCmdTTL.klass = rb_define_class_under(mOgre, "CmdTTL", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdTTL, (void *) &SwigClassCmdTTL);
  rb_define_alloc_func(SwigClassCmdTTL.klass, _wrap_CmdTTL_allocate);
  rb_define_method(SwigClassCmdTTL.klass, "initialize", VALUEFUNC(_wrap_new_CmdTTL), -1);
  rb_define_method(SwigClassCmdTTL.klass, "doGet", VALUEFUNC(_wrap_CmdTTL_doGet), -1);
  rb_define_method(SwigClassCmdTTL.klass, "doSet", VALUEFUNC(_wrap_CmdTTL_doSet), -1);
  SwigClassCmdTTL.mark = 0;
  SwigClassCmdTTL.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdTTL;
  SwigClassCmdTTL.trackObjects = 0;
  
  SwigClassCmdMinTTL.klass = rb_define_class_under(mOgre, "CmdMinTTL", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMinTTL, (void *) &SwigClassCmdMinTTL);
  rb_define_alloc_func(SwigClassCmdMinTTL.klass, _wrap_CmdMinTTL_allocate);
  rb_define_method(SwigClassCmdMinTTL.klass, "initialize", VALUEFUNC(_wrap_new_CmdMinTTL), -1);
  rb_define_method(SwigClassCmdMinTTL.klass, "doGet", VALUEFUNC(_wrap_CmdMinTTL_doGet), -1);
  rb_define_method(SwigClassCmdMinTTL.klass, "doSet", VALUEFUNC(_wrap_CmdMinTTL_doSet), -1);
  SwigClassCmdMinTTL.mark = 0;
  SwigClassCmdMinTTL.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMinTTL;
  SwigClassCmdMinTTL.trackObjects = 0;
  
  SwigClassCmdMaxTTL.klass = rb_define_class_under(mOgre, "CmdMaxTTL", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxTTL, (void *) &SwigClassCmdMaxTTL);
  rb_define_alloc_func(SwigClassCmdMaxTTL.klass, _wrap_CmdMaxTTL_allocate);
  rb_define_method(SwigClassCmdMaxTTL.klass, "initialize", VALUEFUNC(_wrap_new_CmdMaxTTL), -1);
  rb_define_method(SwigClassCmdMaxTTL.klass, "doGet", VALUEFUNC(_wrap_CmdMaxTTL_doGet), -1);
  rb_define_method(SwigClassCmdMaxTTL.klass, "doSet", VALUEFUNC(_wrap_CmdMaxTTL_doSet), -1);
  SwigClassCmdMaxTTL.mark = 0;
  SwigClassCmdMaxTTL.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMaxTTL;
  SwigClassCmdMaxTTL.trackObjects = 0;
  
  SwigClassCmdPosition.klass = rb_define_class_under(mOgre, "CmdPosition", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdPosition, (void *) &SwigClassCmdPosition);
  rb_define_alloc_func(SwigClassCmdPosition.klass, _wrap_CmdPosition_allocate);
  rb_define_method(SwigClassCmdPosition.klass, "initialize", VALUEFUNC(_wrap_new_CmdPosition), -1);
  rb_define_method(SwigClassCmdPosition.klass, "doGet", VALUEFUNC(_wrap_CmdPosition_doGet), -1);
  rb_define_method(SwigClassCmdPosition.klass, "doSet", VALUEFUNC(_wrap_CmdPosition_doSet), -1);
  SwigClassCmdPosition.mark = 0;
  SwigClassCmdPosition.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdPosition;
  SwigClassCmdPosition.trackObjects = 0;
  
  SwigClassCmdDuration.klass = rb_define_class_under(mOgre, "CmdDuration", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdDuration, (void *) &SwigClassCmdDuration);
  rb_define_alloc_func(SwigClassCmdDuration.klass, _wrap_CmdDuration_allocate);
  rb_define_method(SwigClassCmdDuration.klass, "initialize", VALUEFUNC(_wrap_new_CmdDuration), -1);
  rb_define_method(SwigClassCmdDuration.klass, "doGet", VALUEFUNC(_wrap_CmdDuration_doGet), -1);
  rb_define_method(SwigClassCmdDuration.klass, "doSet", VALUEFUNC(_wrap_CmdDuration_doSet), -1);
  SwigClassCmdDuration.mark = 0;
  SwigClassCmdDuration.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdDuration;
  SwigClassCmdDuration.trackObjects = 0;
  
  SwigClassCmdMinDuration.klass = rb_define_class_under(mOgre, "CmdMinDuration", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMinDuration, (void *) &SwigClassCmdMinDuration);
  rb_define_alloc_func(SwigClassCmdMinDuration.klass, _wrap_CmdMinDuration_allocate);
  rb_define_method(SwigClassCmdMinDuration.klass, "initialize", VALUEFUNC(_wrap_new_CmdMinDuration), -1);
  rb_define_method(SwigClassCmdMinDuration.klass, "doGet", VALUEFUNC(_wrap_CmdMinDuration_doGet), -1);
  rb_define_method(SwigClassCmdMinDuration.klass, "doSet", VALUEFUNC(_wrap_CmdMinDuration_doSet), -1);
  SwigClassCmdMinDuration.mark = 0;
  SwigClassCmdMinDuration.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMinDuration;
  SwigClassCmdMinDuration.trackObjects = 0;
  
  SwigClassCmdMaxDuration.klass = rb_define_class_under(mOgre, "CmdMaxDuration", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxDuration, (void *) &SwigClassCmdMaxDuration);
  rb_define_alloc_func(SwigClassCmdMaxDuration.klass, _wrap_CmdMaxDuration_allocate);
  rb_define_method(SwigClassCmdMaxDuration.klass, "initialize", VALUEFUNC(_wrap_new_CmdMaxDuration), -1);
  rb_define_method(SwigClassCmdMaxDuration.klass, "doGet", VALUEFUNC(_wrap_CmdMaxDuration_doGet), -1);
  rb_define_method(SwigClassCmdMaxDuration.klass, "doSet", VALUEFUNC(_wrap_CmdMaxDuration_doSet), -1);
  SwigClassCmdMaxDuration.mark = 0;
  SwigClassCmdMaxDuration.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMaxDuration;
  SwigClassCmdMaxDuration.trackObjects = 0;
  
  SwigClassCmdRepeatDelay.klass = rb_define_class_under(mOgre, "CmdRepeatDelay", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdRepeatDelay, (void *) &SwigClassCmdRepeatDelay);
  rb_define_alloc_func(SwigClassCmdRepeatDelay.klass, _wrap_CmdRepeatDelay_allocate);
  rb_define_method(SwigClassCmdRepeatDelay.klass, "initialize", VALUEFUNC(_wrap_new_CmdRepeatDelay), -1);
  rb_define_method(SwigClassCmdRepeatDelay.klass, "doGet", VALUEFUNC(_wrap_CmdRepeatDelay_doGet), -1);
  rb_define_method(SwigClassCmdRepeatDelay.klass, "doSet", VALUEFUNC(_wrap_CmdRepeatDelay_doSet), -1);
  SwigClassCmdRepeatDelay.mark = 0;
  SwigClassCmdRepeatDelay.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdRepeatDelay;
  SwigClassCmdRepeatDelay.trackObjects = 0;
  
  SwigClassCmdMinRepeatDelay.klass = rb_define_class_under(mOgre, "CmdMinRepeatDelay", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMinRepeatDelay, (void *) &SwigClassCmdMinRepeatDelay);
  rb_define_alloc_func(SwigClassCmdMinRepeatDelay.klass, _wrap_CmdMinRepeatDelay_allocate);
  rb_define_method(SwigClassCmdMinRepeatDelay.klass, "initialize", VALUEFUNC(_wrap_new_CmdMinRepeatDelay), -1);
  rb_define_method(SwigClassCmdMinRepeatDelay.klass, "doGet", VALUEFUNC(_wrap_CmdMinRepeatDelay_doGet), -1);
  rb_define_method(SwigClassCmdMinRepeatDelay.klass, "doSet", VALUEFUNC(_wrap_CmdMinRepeatDelay_doSet), -1);
  SwigClassCmdMinRepeatDelay.mark = 0;
  SwigClassCmdMinRepeatDelay.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMinRepeatDelay;
  SwigClassCmdMinRepeatDelay.trackObjects = 0;
  
  SwigClassCmdMaxRepeatDelay.klass = rb_define_class_under(mOgre, "CmdMaxRepeatDelay", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdMaxRepeatDelay, (void *) &SwigClassCmdMaxRepeatDelay);
  rb_define_alloc_func(SwigClassCmdMaxRepeatDelay.klass, _wrap_CmdMaxRepeatDelay_allocate);
  rb_define_method(SwigClassCmdMaxRepeatDelay.klass, "initialize", VALUEFUNC(_wrap_new_CmdMaxRepeatDelay), -1);
  rb_define_method(SwigClassCmdMaxRepeatDelay.klass, "doGet", VALUEFUNC(_wrap_CmdMaxRepeatDelay_doGet), -1);
  rb_define_method(SwigClassCmdMaxRepeatDelay.klass, "doSet", VALUEFUNC(_wrap_CmdMaxRepeatDelay_doSet), -1);
  SwigClassCmdMaxRepeatDelay.mark = 0;
  SwigClassCmdMaxRepeatDelay.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdMaxRepeatDelay;
  SwigClassCmdMaxRepeatDelay.trackObjects = 0;
  
  SwigClassCmdName.klass = rb_define_class_under(mOgre, "CmdName", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdName, (void *) &SwigClassCmdName);
  rb_define_alloc_func(SwigClassCmdName.klass, _wrap_CmdName_allocate);
  rb_define_method(SwigClassCmdName.klass, "initialize", VALUEFUNC(_wrap_new_CmdName), -1);
  rb_define_method(SwigClassCmdName.klass, "doGet", VALUEFUNC(_wrap_CmdName_doGet), -1);
  rb_define_method(SwigClassCmdName.klass, "doSet", VALUEFUNC(_wrap_CmdName_doSet), -1);
  SwigClassCmdName.mark = 0;
  SwigClassCmdName.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdName;
  SwigClassCmdName.trackObjects = 0;
  
  SwigClassCmdEmittedEmitter.klass = rb_define_class_under(mOgre, "CmdEmittedEmitter", ((swig_class *) SWIGTYPE_p_Ogre__ParamCommand->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmitterCommands__CmdEmittedEmitter, (void *) &SwigClassCmdEmittedEmitter);
  rb_define_alloc_func(SwigClassCmdEmittedEmitter.klass, _wrap_CmdEmittedEmitter_allocate);
  rb_define_method(SwigClassCmdEmittedEmitter.klass, "initialize", VALUEFUNC(_wrap_new_CmdEmittedEmitter), -1);
  rb_define_method(SwigClassCmdEmittedEmitter.klass, "doGet", VALUEFUNC(_wrap_CmdEmittedEmitter_doGet), -1);
  rb_define_method(SwigClassCmdEmittedEmitter.klass, "doSet", VALUEFUNC(_wrap_CmdEmittedEmitter_doSet), -1);
  SwigClassCmdEmittedEmitter.mark = 0;
  SwigClassCmdEmittedEmitter.destroy = (void (*)(void *)) free_Ogre_EmitterCommands_CmdEmittedEmitter;
  SwigClassCmdEmittedEmitter.trackObjects = 0;
  
  SwigClassParticleEmitter.klass = rb_define_class_under(mOgre, "ParticleEmitter", ((swig_class *) SWIGTYPE_p_Ogre__StringInterface->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleEmitter, (void *) &SwigClassParticleEmitter);
  rb_undef_alloc_func(SwigClassParticleEmitter.klass);
  rb_define_method(SwigClassParticleEmitter.klass, "setPosition", VALUEFUNC(_wrap_ParticleEmitter_setPosition), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getPosition", VALUEFUNC(_wrap_ParticleEmitter_getPosition), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setDirection", VALUEFUNC(_wrap_ParticleEmitter_setDirection), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getDirection", VALUEFUNC(_wrap_ParticleEmitter_getDirection), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setUp", VALUEFUNC(_wrap_ParticleEmitter_setUp), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getUp", VALUEFUNC(_wrap_ParticleEmitter_getUp), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setAngle", VALUEFUNC(_wrap_ParticleEmitter_setAngle), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getAngle", VALUEFUNC(_wrap_ParticleEmitter_getAngle), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setParticleVelocity", VALUEFUNC(_wrap_ParticleEmitter_setParticleVelocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMinParticleVelocity", VALUEFUNC(_wrap_ParticleEmitter_setMinParticleVelocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMaxParticleVelocity", VALUEFUNC(_wrap_ParticleEmitter_setMaxParticleVelocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getParticleVelocity", VALUEFUNC(_wrap_ParticleEmitter_getParticleVelocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMinParticleVelocity", VALUEFUNC(_wrap_ParticleEmitter_getMinParticleVelocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMaxParticleVelocity", VALUEFUNC(_wrap_ParticleEmitter_getMaxParticleVelocity), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setEmissionRate", VALUEFUNC(_wrap_ParticleEmitter_setEmissionRate), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getEmissionRate", VALUEFUNC(_wrap_ParticleEmitter_getEmissionRate), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setTimeToLive", VALUEFUNC(_wrap_ParticleEmitter_setTimeToLive), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMinTimeToLive", VALUEFUNC(_wrap_ParticleEmitter_setMinTimeToLive), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMaxTimeToLive", VALUEFUNC(_wrap_ParticleEmitter_setMaxTimeToLive), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getTimeToLive", VALUEFUNC(_wrap_ParticleEmitter_getTimeToLive), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMinTimeToLive", VALUEFUNC(_wrap_ParticleEmitter_getMinTimeToLive), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMaxTimeToLive", VALUEFUNC(_wrap_ParticleEmitter_getMaxTimeToLive), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setColour", VALUEFUNC(_wrap_ParticleEmitter_setColour), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setColourRangeStart", VALUEFUNC(_wrap_ParticleEmitter_setColourRangeStart), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setColourRangeEnd", VALUEFUNC(_wrap_ParticleEmitter_setColourRangeEnd), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getColour", VALUEFUNC(_wrap_ParticleEmitter_getColour), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getColourRangeStart", VALUEFUNC(_wrap_ParticleEmitter_getColourRangeStart), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getColourRangeEnd", VALUEFUNC(_wrap_ParticleEmitter_getColourRangeEnd), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "_getEmissionCount", VALUEFUNC(_wrap_ParticleEmitter__getEmissionCount), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "_initParticle", VALUEFUNC(_wrap_ParticleEmitter__initParticle), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getType", VALUEFUNC(_wrap_ParticleEmitter_getType), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setEnabled", VALUEFUNC(_wrap_ParticleEmitter_setEnabled), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getEnabled", VALUEFUNC(_wrap_ParticleEmitter_getEnabled), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setStartTime", VALUEFUNC(_wrap_ParticleEmitter_setStartTime), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getStartTime", VALUEFUNC(_wrap_ParticleEmitter_getStartTime), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getDuration", VALUEFUNC(_wrap_ParticleEmitter_getDuration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setDuration", VALUEFUNC(_wrap_ParticleEmitter_setDuration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMinDuration", VALUEFUNC(_wrap_ParticleEmitter_setMinDuration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMaxDuration", VALUEFUNC(_wrap_ParticleEmitter_setMaxDuration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMinDuration", VALUEFUNC(_wrap_ParticleEmitter_getMinDuration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMaxDuration", VALUEFUNC(_wrap_ParticleEmitter_getMaxDuration), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getRepeatDelay", VALUEFUNC(_wrap_ParticleEmitter_getRepeatDelay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setRepeatDelay", VALUEFUNC(_wrap_ParticleEmitter_setRepeatDelay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMinRepeatDelay", VALUEFUNC(_wrap_ParticleEmitter_setMinRepeatDelay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setMaxRepeatDelay", VALUEFUNC(_wrap_ParticleEmitter_setMaxRepeatDelay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMinRepeatDelay", VALUEFUNC(_wrap_ParticleEmitter_getMinRepeatDelay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getMaxRepeatDelay", VALUEFUNC(_wrap_ParticleEmitter_getMaxRepeatDelay), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getName", VALUEFUNC(_wrap_ParticleEmitter_getName), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setName", VALUEFUNC(_wrap_ParticleEmitter_setName), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "getEmittedEmitter", VALUEFUNC(_wrap_ParticleEmitter_getEmittedEmitter), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setEmittedEmitter", VALUEFUNC(_wrap_ParticleEmitter_setEmittedEmitter), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "isEmitted", VALUEFUNC(_wrap_ParticleEmitter_isEmitted), -1);
  rb_define_method(SwigClassParticleEmitter.klass, "setEmitted", VALUEFUNC(_wrap_ParticleEmitter_setEmitted), -1);
  SwigClassParticleEmitter.mark = 0;
  SwigClassParticleEmitter.destroy = (void (*)(void *)) free_Ogre_ParticleEmitter;
  SwigClassParticleEmitter.trackObjects = 0;
  
  SwigClassParticleEmitterFactory.klass = rb_define_class_under(mOgre, "ParticleEmitterFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleEmitterFactory, (void *) &SwigClassParticleEmitterFactory);
  rb_undef_alloc_func(SwigClassParticleEmitterFactory.klass);
  rb_define_method(SwigClassParticleEmitterFactory.klass, "getName", VALUEFUNC(_wrap_ParticleEmitterFactory_getName), -1);
  rb_define_method(SwigClassParticleEmitterFactory.klass, "createEmitter", VALUEFUNC(_wrap_ParticleEmitterFactory_createEmitter), -1);
  rb_define_method(SwigClassParticleEmitterFactory.klass, "destroyEmitter", VALUEFUNC(_wrap_ParticleEmitterFactory_destroyEmitter), -1);
  SwigClassParticleEmitterFactory.mark = 0;
  SwigClassParticleEmitterFactory.destroy = (void (*)(void *)) free_Ogre_ParticleEmitterFactory;
  SwigClassParticleEmitterFactory.trackObjects = 0;
  
  SwigClassParticleIterator.klass = rb_define_class_under(mOgre, "ParticleIterator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleIterator, (void *) &SwigClassParticleIterator);
  rb_undef_alloc_func(SwigClassParticleIterator.klass);
  rb_define_method(SwigClassParticleIterator.klass, "end", VALUEFUNC(_wrap_ParticleIterator_end), -1);
  rb_define_method(SwigClassParticleIterator.klass, "getNext", VALUEFUNC(_wrap_ParticleIterator_getNext), -1);
  SwigClassParticleIterator.mark = 0;
  SwigClassParticleIterator.destroy = (void (*)(void *)) free_Ogre_ParticleIterator;
  SwigClassParticleIterator.trackObjects = 0;
  rb_define_const(mOgre, "CNT_VARIABLE", SWIG_From_int(static_cast< int >(Ogre::CNT_VARIABLE)));
  rb_define_const(mOgre, "CNT_VARIABLE_ASSIGN", SWIG_From_int(static_cast< int >(Ogre::CNT_VARIABLE_ASSIGN)));
  rb_define_const(mOgre, "CNT_WORD", SWIG_From_int(static_cast< int >(Ogre::CNT_WORD)));
  rb_define_const(mOgre, "CNT_IMPORT", SWIG_From_int(static_cast< int >(Ogre::CNT_IMPORT)));
  rb_define_const(mOgre, "CNT_QUOTE", SWIG_From_int(static_cast< int >(Ogre::CNT_QUOTE)));
  rb_define_const(mOgre, "CNT_LBRACE", SWIG_From_int(static_cast< int >(Ogre::CNT_LBRACE)));
  rb_define_const(mOgre, "CNT_RBRACE", SWIG_From_int(static_cast< int >(Ogre::CNT_RBRACE)));
  rb_define_const(mOgre, "CNT_COLON", SWIG_From_int(static_cast< int >(Ogre::CNT_COLON)));
  
  SwigClassConcreteNode.klass = rb_define_class_under(mOgre, "ConcreteNode", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ConcreteNode, (void *) &SwigClassConcreteNode);
  rb_define_alloc_func(SwigClassConcreteNode.klass, _wrap_ConcreteNode_allocate);
  rb_define_method(SwigClassConcreteNode.klass, "initialize", VALUEFUNC(_wrap_new_ConcreteNode), -1);
  rb_define_method(SwigClassConcreteNode.klass, "token=", VALUEFUNC(_wrap_ConcreteNode_token_set), -1);
  rb_define_method(SwigClassConcreteNode.klass, "token", VALUEFUNC(_wrap_ConcreteNode_token_get), -1);
  rb_define_method(SwigClassConcreteNode.klass, "file=", VALUEFUNC(_wrap_ConcreteNode_file_set), -1);
  rb_define_method(SwigClassConcreteNode.klass, "file", VALUEFUNC(_wrap_ConcreteNode_file_get), -1);
  rb_define_method(SwigClassConcreteNode.klass, "line=", VALUEFUNC(_wrap_ConcreteNode_line_set), -1);
  rb_define_method(SwigClassConcreteNode.klass, "line", VALUEFUNC(_wrap_ConcreteNode_line_get), -1);
  rb_define_method(SwigClassConcreteNode.klass, "type=", VALUEFUNC(_wrap_ConcreteNode_type_set), -1);
  rb_define_method(SwigClassConcreteNode.klass, "type", VALUEFUNC(_wrap_ConcreteNode_type_get), -1);
  rb_define_method(SwigClassConcreteNode.klass, "children=", VALUEFUNC(_wrap_ConcreteNode_children_set), -1);
  rb_define_method(SwigClassConcreteNode.klass, "children", VALUEFUNC(_wrap_ConcreteNode_children_get), -1);
  rb_define_method(SwigClassConcreteNode.klass, "parent=", VALUEFUNC(_wrap_ConcreteNode_parent_set), -1);
  rb_define_method(SwigClassConcreteNode.klass, "parent", VALUEFUNC(_wrap_ConcreteNode_parent_get), -1);
  SwigClassConcreteNode.mark = 0;
  SwigClassConcreteNode.destroy = (void (*)(void *)) free_Ogre_ConcreteNode;
  SwigClassConcreteNode.trackObjects = 0;
  rb_define_const(mOgre, "ANT_UNKNOWN", SWIG_From_int(static_cast< int >(Ogre::ANT_UNKNOWN)));
  rb_define_const(mOgre, "ANT_ATOM", SWIG_From_int(static_cast< int >(Ogre::ANT_ATOM)));
  rb_define_const(mOgre, "ANT_OBJECT", SWIG_From_int(static_cast< int >(Ogre::ANT_OBJECT)));
  rb_define_const(mOgre, "ANT_PROPERTY", SWIG_From_int(static_cast< int >(Ogre::ANT_PROPERTY)));
  rb_define_const(mOgre, "ANT_IMPORT", SWIG_From_int(static_cast< int >(Ogre::ANT_IMPORT)));
  rb_define_const(mOgre, "ANT_VARIABLE_SET", SWIG_From_int(static_cast< int >(Ogre::ANT_VARIABLE_SET)));
  rb_define_const(mOgre, "ANT_VARIABLE_ACCESS", SWIG_From_int(static_cast< int >(Ogre::ANT_VARIABLE_ACCESS)));
  
  SwigClassAbstractNode.klass = rb_define_class_under(mOgre, "AbstractNode", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AbstractNode, (void *) &SwigClassAbstractNode);
  rb_undef_alloc_func(SwigClassAbstractNode.klass);
  rb_define_method(SwigClassAbstractNode.klass, "file=", VALUEFUNC(_wrap_AbstractNode_file_set), -1);
  rb_define_method(SwigClassAbstractNode.klass, "file", VALUEFUNC(_wrap_AbstractNode_file_get), -1);
  rb_define_method(SwigClassAbstractNode.klass, "line=", VALUEFUNC(_wrap_AbstractNode_line_set), -1);
  rb_define_method(SwigClassAbstractNode.klass, "line", VALUEFUNC(_wrap_AbstractNode_line_get), -1);
  rb_define_method(SwigClassAbstractNode.klass, "type=", VALUEFUNC(_wrap_AbstractNode_type_set), -1);
  rb_define_method(SwigClassAbstractNode.klass, "type", VALUEFUNC(_wrap_AbstractNode_type_get), -1);
  rb_define_method(SwigClassAbstractNode.klass, "parent=", VALUEFUNC(_wrap_AbstractNode_parent_set), -1);
  rb_define_method(SwigClassAbstractNode.klass, "parent", VALUEFUNC(_wrap_AbstractNode_parent_get), -1);
  rb_define_method(SwigClassAbstractNode.klass, "context=", VALUEFUNC(_wrap_AbstractNode_context_set), -1);
  rb_define_method(SwigClassAbstractNode.klass, "context", VALUEFUNC(_wrap_AbstractNode_context_get), -1);
  rb_define_method(SwigClassAbstractNode.klass, "clone", VALUEFUNC(_wrap_AbstractNode_clone), -1);
  rb_define_method(SwigClassAbstractNode.klass, "getValue", VALUEFUNC(_wrap_AbstractNode_getValue), -1);
  SwigClassAbstractNode.mark = 0;
  SwigClassAbstractNode.destroy = (void (*)(void *)) free_Ogre_AbstractNode;
  SwigClassAbstractNode.trackObjects = 0;
  
  SwigClassAtomAbstractNode.klass = rb_define_class_under(mOgre, "AtomAbstractNode", ((swig_class *) SWIGTYPE_p_Ogre__AbstractNode->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AtomAbstractNode, (void *) &SwigClassAtomAbstractNode);
  rb_define_alloc_func(SwigClassAtomAbstractNode.klass, _wrap_AtomAbstractNode_allocate);
  rb_define_method(SwigClassAtomAbstractNode.klass, "initialize", VALUEFUNC(_wrap_new_AtomAbstractNode), -1);
  rb_define_method(SwigClassAtomAbstractNode.klass, "value=", VALUEFUNC(_wrap_AtomAbstractNode_value_set), -1);
  rb_define_method(SwigClassAtomAbstractNode.klass, "value", VALUEFUNC(_wrap_AtomAbstractNode_value_get), -1);
  rb_define_method(SwigClassAtomAbstractNode.klass, "id=", VALUEFUNC(_wrap_AtomAbstractNode_id_set), -1);
  rb_define_method(SwigClassAtomAbstractNode.klass, "id", VALUEFUNC(_wrap_AtomAbstractNode_id_get), -1);
  rb_define_method(SwigClassAtomAbstractNode.klass, "clone", VALUEFUNC(_wrap_AtomAbstractNode_clone), -1);
  rb_define_method(SwigClassAtomAbstractNode.klass, "getValue", VALUEFUNC(_wrap_AtomAbstractNode_getValue), -1);
  SwigClassAtomAbstractNode.mark = 0;
  SwigClassAtomAbstractNode.destroy = (void (*)(void *)) free_Ogre_AtomAbstractNode;
  SwigClassAtomAbstractNode.trackObjects = 0;
  
  SwigClassObjectAbstractNode.klass = rb_define_class_under(mOgre, "ObjectAbstractNode", ((swig_class *) SWIGTYPE_p_Ogre__AbstractNode->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ObjectAbstractNode, (void *) &SwigClassObjectAbstractNode);
  rb_define_alloc_func(SwigClassObjectAbstractNode.klass, _wrap_ObjectAbstractNode_allocate);
  rb_define_method(SwigClassObjectAbstractNode.klass, "initialize", VALUEFUNC(_wrap_new_ObjectAbstractNode), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "name=", VALUEFUNC(_wrap_ObjectAbstractNode_name_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "name", VALUEFUNC(_wrap_ObjectAbstractNode_name_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "cls=", VALUEFUNC(_wrap_ObjectAbstractNode_cls_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "cls", VALUEFUNC(_wrap_ObjectAbstractNode_cls_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "bases=", VALUEFUNC(_wrap_ObjectAbstractNode_bases_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "bases", VALUEFUNC(_wrap_ObjectAbstractNode_bases_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "id=", VALUEFUNC(_wrap_ObjectAbstractNode_id_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "id", VALUEFUNC(_wrap_ObjectAbstractNode_id_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "abstract=", VALUEFUNC(_wrap_ObjectAbstractNode_abstract_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "abstract", VALUEFUNC(_wrap_ObjectAbstractNode_abstract_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "children=", VALUEFUNC(_wrap_ObjectAbstractNode_children_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "children", VALUEFUNC(_wrap_ObjectAbstractNode_children_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "values=", VALUEFUNC(_wrap_ObjectAbstractNode_values_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "values", VALUEFUNC(_wrap_ObjectAbstractNode_values_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "overrides=", VALUEFUNC(_wrap_ObjectAbstractNode_overrides_set), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "overrides", VALUEFUNC(_wrap_ObjectAbstractNode_overrides_get), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "clone", VALUEFUNC(_wrap_ObjectAbstractNode_clone), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "getValue", VALUEFUNC(_wrap_ObjectAbstractNode_getValue), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "addVariable", VALUEFUNC(_wrap_ObjectAbstractNode_addVariable), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "setVariable", VALUEFUNC(_wrap_ObjectAbstractNode_setVariable), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "getVariable", VALUEFUNC(_wrap_ObjectAbstractNode_getVariable), -1);
  rb_define_method(SwigClassObjectAbstractNode.klass, "getVariables", VALUEFUNC(_wrap_ObjectAbstractNode_getVariables), -1);
  SwigClassObjectAbstractNode.mark = 0;
  SwigClassObjectAbstractNode.destroy = (void (*)(void *)) free_Ogre_ObjectAbstractNode;
  SwigClassObjectAbstractNode.trackObjects = 0;
  
  SwigClassPropertyAbstractNode.klass = rb_define_class_under(mOgre, "PropertyAbstractNode", ((swig_class *) SWIGTYPE_p_Ogre__AbstractNode->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PropertyAbstractNode, (void *) &SwigClassPropertyAbstractNode);
  rb_define_alloc_func(SwigClassPropertyAbstractNode.klass, _wrap_PropertyAbstractNode_allocate);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "initialize", VALUEFUNC(_wrap_new_PropertyAbstractNode), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "name=", VALUEFUNC(_wrap_PropertyAbstractNode_name_set), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "name", VALUEFUNC(_wrap_PropertyAbstractNode_name_get), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "id=", VALUEFUNC(_wrap_PropertyAbstractNode_id_set), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "id", VALUEFUNC(_wrap_PropertyAbstractNode_id_get), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "values=", VALUEFUNC(_wrap_PropertyAbstractNode_values_set), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "values", VALUEFUNC(_wrap_PropertyAbstractNode_values_get), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "clone", VALUEFUNC(_wrap_PropertyAbstractNode_clone), -1);
  rb_define_method(SwigClassPropertyAbstractNode.klass, "getValue", VALUEFUNC(_wrap_PropertyAbstractNode_getValue), -1);
  SwigClassPropertyAbstractNode.mark = 0;
  SwigClassPropertyAbstractNode.destroy = (void (*)(void *)) free_Ogre_PropertyAbstractNode;
  SwigClassPropertyAbstractNode.trackObjects = 0;
  
  SwigClassImportAbstractNode.klass = rb_define_class_under(mOgre, "ImportAbstractNode", ((swig_class *) SWIGTYPE_p_Ogre__AbstractNode->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ImportAbstractNode, (void *) &SwigClassImportAbstractNode);
  rb_define_alloc_func(SwigClassImportAbstractNode.klass, _wrap_ImportAbstractNode_allocate);
  rb_define_method(SwigClassImportAbstractNode.klass, "initialize", VALUEFUNC(_wrap_new_ImportAbstractNode), -1);
  rb_define_method(SwigClassImportAbstractNode.klass, "target=", VALUEFUNC(_wrap_ImportAbstractNode_target_set), -1);
  rb_define_method(SwigClassImportAbstractNode.klass, "target", VALUEFUNC(_wrap_ImportAbstractNode_target_get), -1);
  rb_define_method(SwigClassImportAbstractNode.klass, "source=", VALUEFUNC(_wrap_ImportAbstractNode_source_set), -1);
  rb_define_method(SwigClassImportAbstractNode.klass, "source", VALUEFUNC(_wrap_ImportAbstractNode_source_get), -1);
  rb_define_method(SwigClassImportAbstractNode.klass, "clone", VALUEFUNC(_wrap_ImportAbstractNode_clone), -1);
  rb_define_method(SwigClassImportAbstractNode.klass, "getValue", VALUEFUNC(_wrap_ImportAbstractNode_getValue), -1);
  SwigClassImportAbstractNode.mark = 0;
  SwigClassImportAbstractNode.destroy = (void (*)(void *)) free_Ogre_ImportAbstractNode;
  SwigClassImportAbstractNode.trackObjects = 0;
  
  SwigClassVariableAccessAbstractNode.klass = rb_define_class_under(mOgre, "VariableAccessAbstractNode", ((swig_class *) SWIGTYPE_p_Ogre__AbstractNode->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VariableAccessAbstractNode, (void *) &SwigClassVariableAccessAbstractNode);
  rb_define_alloc_func(SwigClassVariableAccessAbstractNode.klass, _wrap_VariableAccessAbstractNode_allocate);
  rb_define_method(SwigClassVariableAccessAbstractNode.klass, "initialize", VALUEFUNC(_wrap_new_VariableAccessAbstractNode), -1);
  rb_define_method(SwigClassVariableAccessAbstractNode.klass, "name=", VALUEFUNC(_wrap_VariableAccessAbstractNode_name_set), -1);
  rb_define_method(SwigClassVariableAccessAbstractNode.klass, "name", VALUEFUNC(_wrap_VariableAccessAbstractNode_name_get), -1);
  rb_define_method(SwigClassVariableAccessAbstractNode.klass, "clone", VALUEFUNC(_wrap_VariableAccessAbstractNode_clone), -1);
  rb_define_method(SwigClassVariableAccessAbstractNode.klass, "getValue", VALUEFUNC(_wrap_VariableAccessAbstractNode_getValue), -1);
  SwigClassVariableAccessAbstractNode.mark = 0;
  SwigClassVariableAccessAbstractNode.destroy = (void (*)(void *)) free_Ogre_VariableAccessAbstractNode;
  SwigClassVariableAccessAbstractNode.trackObjects = 0;
  
  SwigClassScriptCompiler.klass = rb_define_class_under(mOgre, "ScriptCompiler", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptCompiler, (void *) &SwigClassScriptCompiler);
  rb_define_alloc_func(SwigClassScriptCompiler.klass, _wrap_ScriptCompiler_allocate);
  rb_define_method(SwigClassScriptCompiler.klass, "initialize", VALUEFUNC(_wrap_new_ScriptCompiler), -1);
  rb_define_const(SwigClassScriptCompiler.klass, "CE_STRINGEXPECTED", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_STRINGEXPECTED)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_NUMBEREXPECTED", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_NUMBEREXPECTED)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_FEWERPARAMETERSEXPECTED", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_FEWERPARAMETERSEXPECTED)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_VARIABLEEXPECTED", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_VARIABLEEXPECTED)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_UNDEFINEDVARIABLE", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_UNDEFINEDVARIABLE)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_OBJECTNAMEEXPECTED", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_OBJECTNAMEEXPECTED)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_OBJECTALLOCATIONERROR", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_OBJECTALLOCATIONERROR)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_INVALIDPARAMETERS", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_INVALIDPARAMETERS)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_DUPLICATEOVERRIDE", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_DUPLICATEOVERRIDE)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_UNEXPECTEDTOKEN", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_UNEXPECTEDTOKEN)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_OBJECTBASENOTFOUND", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_OBJECTBASENOTFOUND)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_UNSUPPORTEDBYRENDERSYSTEM", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_UNSUPPORTEDBYRENDERSYSTEM)));
  rb_define_const(SwigClassScriptCompiler.klass, "CE_REFERENCETOANONEXISTINGOBJECT", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT)));
  rb_define_singleton_method(SwigClassScriptCompiler.klass, "formatErrorCode", VALUEFUNC(_wrap_ScriptCompiler_formatErrorCode), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "compile", VALUEFUNC(_wrap_ScriptCompiler_compile), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "_generateAST", VALUEFUNC(_wrap_ScriptCompiler__generateAST), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "_compile", VALUEFUNC(_wrap_ScriptCompiler__compile), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "addError", VALUEFUNC(_wrap_ScriptCompiler_addError), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "setListener", VALUEFUNC(_wrap_ScriptCompiler_setListener), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "getListener", VALUEFUNC(_wrap_ScriptCompiler_getListener), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "getResourceGroup", VALUEFUNC(_wrap_ScriptCompiler_getResourceGroup), -1);
  rb_define_method(SwigClassScriptCompiler.klass, "_fireEvent", VALUEFUNC(_wrap_ScriptCompiler__fireEvent), -1);
  rb_define_const(SwigClassScriptCompiler.klass, "ID_ON", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::ID_ON)));
  rb_define_const(SwigClassScriptCompiler.klass, "ID_OFF", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::ID_OFF)));
  rb_define_const(SwigClassScriptCompiler.klass, "ID_TRUE", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::ID_TRUE)));
  rb_define_const(SwigClassScriptCompiler.klass, "ID_FALSE", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::ID_FALSE)));
  rb_define_const(SwigClassScriptCompiler.klass, "ID_YES", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::ID_YES)));
  rb_define_const(SwigClassScriptCompiler.klass, "ID_NO", SWIG_From_int(static_cast< int >(Ogre::ScriptCompiler::ID_NO)));
  SwigClassScriptCompiler.mark = 0;
  SwigClassScriptCompiler.destroy = (void (*)(void *)) free_Ogre_ScriptCompiler;
  SwigClassScriptCompiler.trackObjects = 0;
  
  SwigClassScriptCompilerEvent.klass = rb_define_class_under(mOgre, "ScriptCompilerEvent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptCompilerEvent, (void *) &SwigClassScriptCompilerEvent);
  rb_define_alloc_func(SwigClassScriptCompilerEvent.klass, _wrap_ScriptCompilerEvent_allocate);
  rb_define_method(SwigClassScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_ScriptCompilerEvent), -1);
  rb_define_method(SwigClassScriptCompilerEvent.klass, "mType=", VALUEFUNC(_wrap_ScriptCompilerEvent_mType_set), -1);
  rb_define_method(SwigClassScriptCompilerEvent.klass, "mType", VALUEFUNC(_wrap_ScriptCompilerEvent_mType_get), -1);
  SwigClassScriptCompilerEvent.mark = 0;
  SwigClassScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_ScriptCompilerEvent;
  SwigClassScriptCompilerEvent.trackObjects = 0;
  
  SwigClassScriptCompilerListener.klass = rb_define_class_under(mOgre, "ScriptCompilerListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptCompilerListener, (void *) &SwigClassScriptCompilerListener);
  rb_define_alloc_func(SwigClassScriptCompilerListener.klass, _wrap_ScriptCompilerListener_allocate);
  rb_define_method(SwigClassScriptCompilerListener.klass, "initialize", VALUEFUNC(_wrap_new_ScriptCompilerListener), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "importFile", VALUEFUNC(_wrap_ScriptCompilerListener_importFile), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "preConversion", VALUEFUNC(_wrap_ScriptCompilerListener_preConversion), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "postConversion", VALUEFUNC(_wrap_ScriptCompilerListener_postConversion), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "handleError", VALUEFUNC(_wrap_ScriptCompilerListener_handleError), -1);
  rb_define_method(SwigClassScriptCompilerListener.klass, "handleEvent", VALUEFUNC(_wrap_ScriptCompilerListener_handleEvent), -1);
  SwigClassScriptCompilerListener.mark = 0;
  SwigClassScriptCompilerListener.destroy = (void (*)(void *)) free_Ogre_ScriptCompilerListener;
  SwigClassScriptCompilerListener.trackObjects = 0;
  
  SwigClassScriptCompilerManager.klass = rb_define_class_under(mOgre, "ScriptCompilerManager", ((swig_class *) SWIGTYPE_p_Ogre__ScriptLoader->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptCompilerManager, (void *) &SwigClassScriptCompilerManager);
  rb_define_alloc_func(SwigClassScriptCompilerManager.klass, _wrap_ScriptCompilerManager_allocate);
  rb_define_method(SwigClassScriptCompilerManager.klass, "initialize", VALUEFUNC(_wrap_new_ScriptCompilerManager), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "setListener", VALUEFUNC(_wrap_ScriptCompilerManager_setListener), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "getListener", VALUEFUNC(_wrap_ScriptCompilerManager_getListener), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "addTranslatorManager", VALUEFUNC(_wrap_ScriptCompilerManager_addTranslatorManager), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "removeTranslatorManager", VALUEFUNC(_wrap_ScriptCompilerManager_removeTranslatorManager), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "clearTranslatorManagers", VALUEFUNC(_wrap_ScriptCompilerManager_clearTranslatorManagers), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "getTranslator", VALUEFUNC(_wrap_ScriptCompilerManager_getTranslator), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "addScriptPattern", VALUEFUNC(_wrap_ScriptCompilerManager_addScriptPattern), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "getScriptPatterns", VALUEFUNC(_wrap_ScriptCompilerManager_getScriptPatterns), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "parseScript", VALUEFUNC(_wrap_ScriptCompilerManager_parseScript), -1);
  rb_define_method(SwigClassScriptCompilerManager.klass, "getLoadingOrder", VALUEFUNC(_wrap_ScriptCompilerManager_getLoadingOrder), -1);
  rb_define_singleton_method(SwigClassScriptCompilerManager.klass, "getSingleton", VALUEFUNC(_wrap_ScriptCompilerManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassScriptCompilerManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_ScriptCompilerManager_getSingletonPtr), -1);
  SwigClassScriptCompilerManager.mark = 0;
  SwigClassScriptCompilerManager.destroy = (void (*)(void *)) free_Ogre_ScriptCompilerManager;
  SwigClassScriptCompilerManager.trackObjects = 0;
  
  SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass = rb_define_class_under(mOgre, "PreApplyTextureAliasesScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PreApplyTextureAliasesScriptCompilerEvent, (void *) &SwigClassPreApplyTextureAliasesScriptCompilerEvent);
  rb_define_alloc_func(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, _wrap_PreApplyTextureAliasesScriptCompilerEvent_allocate);
  rb_define_method(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_PreApplyTextureAliasesScriptCompilerEvent), -1);
  rb_define_method(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, "mMaterial=", VALUEFUNC(_wrap_PreApplyTextureAliasesScriptCompilerEvent_mMaterial_set), -1);
  rb_define_method(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, "mMaterial", VALUEFUNC(_wrap_PreApplyTextureAliasesScriptCompilerEvent_mMaterial_get), -1);
  rb_define_method(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, "mAliases=", VALUEFUNC(_wrap_PreApplyTextureAliasesScriptCompilerEvent_mAliases_set), -1);
  rb_define_method(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, "mAliases", VALUEFUNC(_wrap_PreApplyTextureAliasesScriptCompilerEvent_mAliases_get), -1);
  rb_define_singleton_method(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_PreApplyTextureAliasesScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassPreApplyTextureAliasesScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_PreApplyTextureAliasesScriptCompilerEvent_eventType_set), 1);
  SwigClassPreApplyTextureAliasesScriptCompilerEvent.mark = 0;
  SwigClassPreApplyTextureAliasesScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_PreApplyTextureAliasesScriptCompilerEvent;
  SwigClassPreApplyTextureAliasesScriptCompilerEvent.trackObjects = 0;
  
  SwigClassProcessResourceNameScriptCompilerEvent.klass = rb_define_class_under(mOgre, "ProcessResourceNameScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ProcessResourceNameScriptCompilerEvent, (void *) &SwigClassProcessResourceNameScriptCompilerEvent);
  rb_define_alloc_func(SwigClassProcessResourceNameScriptCompilerEvent.klass, _wrap_ProcessResourceNameScriptCompilerEvent_allocate);
  rb_define_method(SwigClassProcessResourceNameScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_ProcessResourceNameScriptCompilerEvent), -1);
  rb_define_const(SwigClassProcessResourceNameScriptCompilerEvent.klass, "TEXTURE", SWIG_From_int(static_cast< int >(Ogre::ProcessResourceNameScriptCompilerEvent::TEXTURE)));
  rb_define_const(SwigClassProcessResourceNameScriptCompilerEvent.klass, "MATERIAL", SWIG_From_int(static_cast< int >(Ogre::ProcessResourceNameScriptCompilerEvent::MATERIAL)));
  rb_define_const(SwigClassProcessResourceNameScriptCompilerEvent.klass, "GPU_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::ProcessResourceNameScriptCompilerEvent::GPU_PROGRAM)));
  rb_define_const(SwigClassProcessResourceNameScriptCompilerEvent.klass, "COMPOSITOR", SWIG_From_int(static_cast< int >(Ogre::ProcessResourceNameScriptCompilerEvent::COMPOSITOR)));
  rb_define_method(SwigClassProcessResourceNameScriptCompilerEvent.klass, "mResourceType=", VALUEFUNC(_wrap_ProcessResourceNameScriptCompilerEvent_mResourceType_set), -1);
  rb_define_method(SwigClassProcessResourceNameScriptCompilerEvent.klass, "mResourceType", VALUEFUNC(_wrap_ProcessResourceNameScriptCompilerEvent_mResourceType_get), -1);
  rb_define_method(SwigClassProcessResourceNameScriptCompilerEvent.klass, "mName=", VALUEFUNC(_wrap_ProcessResourceNameScriptCompilerEvent_mName_set), -1);
  rb_define_method(SwigClassProcessResourceNameScriptCompilerEvent.klass, "mName", VALUEFUNC(_wrap_ProcessResourceNameScriptCompilerEvent_mName_get), -1);
  rb_define_singleton_method(SwigClassProcessResourceNameScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_ProcessResourceNameScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassProcessResourceNameScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_ProcessResourceNameScriptCompilerEvent_eventType_set), 1);
  SwigClassProcessResourceNameScriptCompilerEvent.mark = 0;
  SwigClassProcessResourceNameScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_ProcessResourceNameScriptCompilerEvent;
  SwigClassProcessResourceNameScriptCompilerEvent.trackObjects = 0;
  
  SwigClassProcessNameExclusionScriptCompilerEvent.klass = rb_define_class_under(mOgre, "ProcessNameExclusionScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ProcessNameExclusionScriptCompilerEvent, (void *) &SwigClassProcessNameExclusionScriptCompilerEvent);
  rb_define_alloc_func(SwigClassProcessNameExclusionScriptCompilerEvent.klass, _wrap_ProcessNameExclusionScriptCompilerEvent_allocate);
  rb_define_method(SwigClassProcessNameExclusionScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_ProcessNameExclusionScriptCompilerEvent), -1);
  rb_define_method(SwigClassProcessNameExclusionScriptCompilerEvent.klass, "mClass=", VALUEFUNC(_wrap_ProcessNameExclusionScriptCompilerEvent_mClass_set), -1);
  rb_define_method(SwigClassProcessNameExclusionScriptCompilerEvent.klass, "mClass", VALUEFUNC(_wrap_ProcessNameExclusionScriptCompilerEvent_mClass_get), -1);
  rb_define_method(SwigClassProcessNameExclusionScriptCompilerEvent.klass, "mParent=", VALUEFUNC(_wrap_ProcessNameExclusionScriptCompilerEvent_mParent_set), -1);
  rb_define_method(SwigClassProcessNameExclusionScriptCompilerEvent.klass, "mParent", VALUEFUNC(_wrap_ProcessNameExclusionScriptCompilerEvent_mParent_get), -1);
  rb_define_singleton_method(SwigClassProcessNameExclusionScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_ProcessNameExclusionScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassProcessNameExclusionScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_ProcessNameExclusionScriptCompilerEvent_eventType_set), 1);
  SwigClassProcessNameExclusionScriptCompilerEvent.mark = 0;
  SwigClassProcessNameExclusionScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_ProcessNameExclusionScriptCompilerEvent;
  SwigClassProcessNameExclusionScriptCompilerEvent.trackObjects = 0;
  
  SwigClassCreateMaterialScriptCompilerEvent.klass = rb_define_class_under(mOgre, "CreateMaterialScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CreateMaterialScriptCompilerEvent, (void *) &SwigClassCreateMaterialScriptCompilerEvent);
  rb_define_alloc_func(SwigClassCreateMaterialScriptCompilerEvent.klass, _wrap_CreateMaterialScriptCompilerEvent_allocate);
  rb_define_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_CreateMaterialScriptCompilerEvent), -1);
  rb_define_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "mFile=", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_mFile_set), -1);
  rb_define_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "mFile", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_mFile_get), -1);
  rb_define_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "mName=", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_mName_set), -1);
  rb_define_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "mName", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_mName_get), -1);
  rb_define_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "mResourceGroup=", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_mResourceGroup_set), -1);
  rb_define_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "mResourceGroup", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_mResourceGroup_get), -1);
  rb_define_singleton_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassCreateMaterialScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_CreateMaterialScriptCompilerEvent_eventType_set), 1);
  SwigClassCreateMaterialScriptCompilerEvent.mark = 0;
  SwigClassCreateMaterialScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_CreateMaterialScriptCompilerEvent;
  SwigClassCreateMaterialScriptCompilerEvent.trackObjects = 0;
  
  SwigClassCreateGpuProgramScriptCompilerEvent.klass = rb_define_class_under(mOgre, "CreateGpuProgramScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CreateGpuProgramScriptCompilerEvent, (void *) &SwigClassCreateGpuProgramScriptCompilerEvent);
  rb_define_alloc_func(SwigClassCreateGpuProgramScriptCompilerEvent.klass, _wrap_CreateGpuProgramScriptCompilerEvent_allocate);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_CreateGpuProgramScriptCompilerEvent), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mFile=", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mFile_set), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mFile", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mFile_get), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mName=", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mName_set), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mName", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mName_get), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mResourceGroup=", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mResourceGroup_set), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mResourceGroup", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mResourceGroup_get), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mSource=", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mSource_set), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mSource", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mSource_get), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mSyntax=", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mSyntax_set), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mSyntax", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mSyntax_get), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mProgramType=", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mProgramType_set), -1);
  rb_define_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "mProgramType", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_mProgramType_get), -1);
  rb_define_singleton_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassCreateGpuProgramScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_CreateGpuProgramScriptCompilerEvent_eventType_set), 1);
  SwigClassCreateGpuProgramScriptCompilerEvent.mark = 0;
  SwigClassCreateGpuProgramScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_CreateGpuProgramScriptCompilerEvent;
  SwigClassCreateGpuProgramScriptCompilerEvent.trackObjects = 0;
  
  SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass = rb_define_class_under(mOgre, "CreateHighLevelGpuProgramScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CreateHighLevelGpuProgramScriptCompilerEvent, (void *) &SwigClassCreateHighLevelGpuProgramScriptCompilerEvent);
  rb_define_alloc_func(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, _wrap_CreateHighLevelGpuProgramScriptCompilerEvent_allocate);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_CreateHighLevelGpuProgramScriptCompilerEvent), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mFile=", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mFile_set), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mFile", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mFile_get), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mName=", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mName_set), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mName", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mName_get), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mResourceGroup=", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mResourceGroup_set), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mResourceGroup", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mResourceGroup_get), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mSource=", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mSource_set), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mSource", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mSource_get), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mLanguage=", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mLanguage_set), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mLanguage", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mLanguage_get), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mProgramType=", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mProgramType_set), -1);
  rb_define_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "mProgramType", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_mProgramType_get), -1);
  rb_define_singleton_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_CreateHighLevelGpuProgramScriptCompilerEvent_eventType_set), 1);
  SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.mark = 0;
  SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_CreateHighLevelGpuProgramScriptCompilerEvent;
  SwigClassCreateHighLevelGpuProgramScriptCompilerEvent.trackObjects = 0;
  
  SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass = rb_define_class_under(mOgre, "CreateGpuSharedParametersScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CreateGpuSharedParametersScriptCompilerEvent, (void *) &SwigClassCreateGpuSharedParametersScriptCompilerEvent);
  rb_define_alloc_func(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, _wrap_CreateGpuSharedParametersScriptCompilerEvent_allocate);
  rb_define_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_CreateGpuSharedParametersScriptCompilerEvent), -1);
  rb_define_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "mFile=", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_mFile_set), -1);
  rb_define_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "mFile", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_mFile_get), -1);
  rb_define_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "mName=", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_mName_set), -1);
  rb_define_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "mName", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_mName_get), -1);
  rb_define_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "mResourceGroup=", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_mResourceGroup_set), -1);
  rb_define_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "mResourceGroup", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_mResourceGroup_get), -1);
  rb_define_singleton_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassCreateGpuSharedParametersScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_CreateGpuSharedParametersScriptCompilerEvent_eventType_set), 1);
  SwigClassCreateGpuSharedParametersScriptCompilerEvent.mark = 0;
  SwigClassCreateGpuSharedParametersScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_CreateGpuSharedParametersScriptCompilerEvent;
  SwigClassCreateGpuSharedParametersScriptCompilerEvent.trackObjects = 0;
  
  SwigClassCreateParticleSystemScriptCompilerEvent.klass = rb_define_class_under(mOgre, "CreateParticleSystemScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CreateParticleSystemScriptCompilerEvent, (void *) &SwigClassCreateParticleSystemScriptCompilerEvent);
  rb_define_alloc_func(SwigClassCreateParticleSystemScriptCompilerEvent.klass, _wrap_CreateParticleSystemScriptCompilerEvent_allocate);
  rb_define_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_CreateParticleSystemScriptCompilerEvent), -1);
  rb_define_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "mFile=", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_mFile_set), -1);
  rb_define_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "mFile", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_mFile_get), -1);
  rb_define_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "mName=", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_mName_set), -1);
  rb_define_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "mName", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_mName_get), -1);
  rb_define_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "mResourceGroup=", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_mResourceGroup_set), -1);
  rb_define_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "mResourceGroup", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_mResourceGroup_get), -1);
  rb_define_singleton_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassCreateParticleSystemScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_CreateParticleSystemScriptCompilerEvent_eventType_set), 1);
  SwigClassCreateParticleSystemScriptCompilerEvent.mark = 0;
  SwigClassCreateParticleSystemScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_CreateParticleSystemScriptCompilerEvent;
  SwigClassCreateParticleSystemScriptCompilerEvent.trackObjects = 0;
  
  SwigClassCreateCompositorScriptCompilerEvent.klass = rb_define_class_under(mOgre, "CreateCompositorScriptCompilerEvent", ((swig_class *) SWIGTYPE_p_Ogre__ScriptCompilerEvent->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CreateCompositorScriptCompilerEvent, (void *) &SwigClassCreateCompositorScriptCompilerEvent);
  rb_define_alloc_func(SwigClassCreateCompositorScriptCompilerEvent.klass, _wrap_CreateCompositorScriptCompilerEvent_allocate);
  rb_define_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "initialize", VALUEFUNC(_wrap_new_CreateCompositorScriptCompilerEvent), -1);
  rb_define_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "mFile=", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_mFile_set), -1);
  rb_define_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "mFile", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_mFile_get), -1);
  rb_define_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "mName=", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_mName_set), -1);
  rb_define_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "mName", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_mName_get), -1);
  rb_define_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "mResourceGroup=", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_mResourceGroup_set), -1);
  rb_define_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "mResourceGroup", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_mResourceGroup_get), -1);
  rb_define_singleton_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "eventType", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_eventType_get), 0);
  rb_define_singleton_method(SwigClassCreateCompositorScriptCompilerEvent.klass, "eventType=", VALUEFUNC(_wrap_CreateCompositorScriptCompilerEvent_eventType_set), 1);
  SwigClassCreateCompositorScriptCompilerEvent.mark = 0;
  SwigClassCreateCompositorScriptCompilerEvent.destroy = (void (*)(void *)) free_Ogre_CreateCompositorScriptCompilerEvent;
  SwigClassCreateCompositorScriptCompilerEvent.trackObjects = 0;
  rb_define_const(mOgre, "ID_MATERIAL", SWIG_From_int(static_cast< int >(Ogre::ID_MATERIAL)));
  rb_define_const(mOgre, "ID_VERTEX_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::ID_VERTEX_PROGRAM)));
  rb_define_const(mOgre, "ID_GEOMETRY_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::ID_GEOMETRY_PROGRAM)));
  rb_define_const(mOgre, "ID_FRAGMENT_PROGRAM", SWIG_From_int(static_cast< int >(Ogre::ID_FRAGMENT_PROGRAM)));
  rb_define_const(mOgre, "ID_TECHNIQUE", SWIG_From_int(static_cast< int >(Ogre::ID_TECHNIQUE)));
  rb_define_const(mOgre, "ID_PASS", SWIG_From_int(static_cast< int >(Ogre::ID_PASS)));
  rb_define_const(mOgre, "ID_TEXTURE_UNIT", SWIG_From_int(static_cast< int >(Ogre::ID_TEXTURE_UNIT)));
  rb_define_const(mOgre, "ID_VERTEX_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::ID_VERTEX_PROGRAM_REF)));
  rb_define_const(mOgre, "ID_GEOMETRY_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::ID_GEOMETRY_PROGRAM_REF)));
  rb_define_const(mOgre, "ID_FRAGMENT_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::ID_FRAGMENT_PROGRAM_REF)));
  rb_define_const(mOgre, "ID_SHADOW_CASTER_VERTEX_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOW_CASTER_VERTEX_PROGRAM_REF)));
  rb_define_const(mOgre, "ID_SHADOW_CASTER_FRAGMENT_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOW_CASTER_FRAGMENT_PROGRAM_REF)));
  rb_define_const(mOgre, "ID_SHADOW_RECEIVER_VERTEX_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOW_RECEIVER_VERTEX_PROGRAM_REF)));
  rb_define_const(mOgre, "ID_SHADOW_RECEIVER_FRAGMENT_PROGRAM_REF", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOW_RECEIVER_FRAGMENT_PROGRAM_REF)));
  rb_define_const(mOgre, "ID_SHADOW_CASTER_MATERIAL", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOW_CASTER_MATERIAL)));
  rb_define_const(mOgre, "ID_SHADOW_RECEIVER_MATERIAL", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOW_RECEIVER_MATERIAL)));
  rb_define_const(mOgre, "ID_LOD_VALUES", SWIG_From_int(static_cast< int >(Ogre::ID_LOD_VALUES)));
  rb_define_const(mOgre, "ID_LOD_STRATEGY", SWIG_From_int(static_cast< int >(Ogre::ID_LOD_STRATEGY)));
  rb_define_const(mOgre, "ID_LOD_DISTANCES", SWIG_From_int(static_cast< int >(Ogre::ID_LOD_DISTANCES)));
  rb_define_const(mOgre, "ID_RECEIVE_SHADOWS", SWIG_From_int(static_cast< int >(Ogre::ID_RECEIVE_SHADOWS)));
  rb_define_const(mOgre, "ID_TRANSPARENCY_CASTS_SHADOWS", SWIG_From_int(static_cast< int >(Ogre::ID_TRANSPARENCY_CASTS_SHADOWS)));
  rb_define_const(mOgre, "ID_SET_TEXTURE_ALIAS", SWIG_From_int(static_cast< int >(Ogre::ID_SET_TEXTURE_ALIAS)));
  rb_define_const(mOgre, "ID_SOURCE", SWIG_From_int(static_cast< int >(Ogre::ID_SOURCE)));
  rb_define_const(mOgre, "ID_SYNTAX", SWIG_From_int(static_cast< int >(Ogre::ID_SYNTAX)));
  rb_define_const(mOgre, "ID_DEFAULT_PARAMS", SWIG_From_int(static_cast< int >(Ogre::ID_DEFAULT_PARAMS)));
  rb_define_const(mOgre, "ID_PARAM_INDEXED", SWIG_From_int(static_cast< int >(Ogre::ID_PARAM_INDEXED)));
  rb_define_const(mOgre, "ID_PARAM_NAMED", SWIG_From_int(static_cast< int >(Ogre::ID_PARAM_NAMED)));
  rb_define_const(mOgre, "ID_PARAM_INDEXED_AUTO", SWIG_From_int(static_cast< int >(Ogre::ID_PARAM_INDEXED_AUTO)));
  rb_define_const(mOgre, "ID_PARAM_NAMED_AUTO", SWIG_From_int(static_cast< int >(Ogre::ID_PARAM_NAMED_AUTO)));
  rb_define_const(mOgre, "ID_SCHEME", SWIG_From_int(static_cast< int >(Ogre::ID_SCHEME)));
  rb_define_const(mOgre, "ID_LOD_INDEX", SWIG_From_int(static_cast< int >(Ogre::ID_LOD_INDEX)));
  rb_define_const(mOgre, "ID_GPU_VENDOR_RULE", SWIG_From_int(static_cast< int >(Ogre::ID_GPU_VENDOR_RULE)));
  rb_define_const(mOgre, "ID_GPU_DEVICE_RULE", SWIG_From_int(static_cast< int >(Ogre::ID_GPU_DEVICE_RULE)));
  rb_define_const(mOgre, "ID_INCLUDE", SWIG_From_int(static_cast< int >(Ogre::ID_INCLUDE)));
  rb_define_const(mOgre, "ID_EXCLUDE", SWIG_From_int(static_cast< int >(Ogre::ID_EXCLUDE)));
  rb_define_const(mOgre, "ID_AMBIENT", SWIG_From_int(static_cast< int >(Ogre::ID_AMBIENT)));
  rb_define_const(mOgre, "ID_DIFFUSE", SWIG_From_int(static_cast< int >(Ogre::ID_DIFFUSE)));
  rb_define_const(mOgre, "ID_SPECULAR", SWIG_From_int(static_cast< int >(Ogre::ID_SPECULAR)));
  rb_define_const(mOgre, "ID_EMISSIVE", SWIG_From_int(static_cast< int >(Ogre::ID_EMISSIVE)));
  rb_define_const(mOgre, "ID_VERTEXCOLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_VERTEXCOLOUR)));
  rb_define_const(mOgre, "ID_SCENE_BLEND", SWIG_From_int(static_cast< int >(Ogre::ID_SCENE_BLEND)));
  rb_define_const(mOgre, "ID_COLOUR_BLEND", SWIG_From_int(static_cast< int >(Ogre::ID_COLOUR_BLEND)));
  rb_define_const(mOgre, "ID_ONE", SWIG_From_int(static_cast< int >(Ogre::ID_ONE)));
  rb_define_const(mOgre, "ID_ZERO", SWIG_From_int(static_cast< int >(Ogre::ID_ZERO)));
  rb_define_const(mOgre, "ID_DEST_COLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_DEST_COLOUR)));
  rb_define_const(mOgre, "ID_SRC_COLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_SRC_COLOUR)));
  rb_define_const(mOgre, "ID_ONE_MINUS_DEST_COLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_ONE_MINUS_DEST_COLOUR)));
  rb_define_const(mOgre, "ID_ONE_MINUS_SRC_COLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_ONE_MINUS_SRC_COLOUR)));
  rb_define_const(mOgre, "ID_DEST_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_DEST_ALPHA)));
  rb_define_const(mOgre, "ID_SRC_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_SRC_ALPHA)));
  rb_define_const(mOgre, "ID_ONE_MINUS_DEST_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_ONE_MINUS_DEST_ALPHA)));
  rb_define_const(mOgre, "ID_ONE_MINUS_SRC_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_ONE_MINUS_SRC_ALPHA)));
  rb_define_const(mOgre, "ID_SEPARATE_SCENE_BLEND", SWIG_From_int(static_cast< int >(Ogre::ID_SEPARATE_SCENE_BLEND)));
  rb_define_const(mOgre, "ID_SCENE_BLEND_OP", SWIG_From_int(static_cast< int >(Ogre::ID_SCENE_BLEND_OP)));
  rb_define_const(mOgre, "ID_REVERSE_SUBTRACT", SWIG_From_int(static_cast< int >(Ogre::ID_REVERSE_SUBTRACT)));
  rb_define_const(mOgre, "ID_MIN", SWIG_From_int(static_cast< int >(Ogre::ID_MIN)));
  rb_define_const(mOgre, "ID_MAX", SWIG_From_int(static_cast< int >(Ogre::ID_MAX)));
  rb_define_const(mOgre, "ID_SEPARATE_SCENE_BLEND_OP", SWIG_From_int(static_cast< int >(Ogre::ID_SEPARATE_SCENE_BLEND_OP)));
  rb_define_const(mOgre, "ID_DEPTH_CHECK", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH_CHECK)));
  rb_define_const(mOgre, "ID_DEPTH_WRITE", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH_WRITE)));
  rb_define_const(mOgre, "ID_DEPTH_FUNC", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH_FUNC)));
  rb_define_const(mOgre, "ID_DEPTH_BIAS", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH_BIAS)));
  rb_define_const(mOgre, "ID_ITERATION_DEPTH_BIAS", SWIG_From_int(static_cast< int >(Ogre::ID_ITERATION_DEPTH_BIAS)));
  rb_define_const(mOgre, "ID_ALWAYS_FAIL", SWIG_From_int(static_cast< int >(Ogre::ID_ALWAYS_FAIL)));
  rb_define_const(mOgre, "ID_ALWAYS_PASS", SWIG_From_int(static_cast< int >(Ogre::ID_ALWAYS_PASS)));
  rb_define_const(mOgre, "ID_LESS_EQUAL", SWIG_From_int(static_cast< int >(Ogre::ID_LESS_EQUAL)));
  rb_define_const(mOgre, "ID_LESS", SWIG_From_int(static_cast< int >(Ogre::ID_LESS)));
  rb_define_const(mOgre, "ID_EQUAL", SWIG_From_int(static_cast< int >(Ogre::ID_EQUAL)));
  rb_define_const(mOgre, "ID_NOT_EQUAL", SWIG_From_int(static_cast< int >(Ogre::ID_NOT_EQUAL)));
  rb_define_const(mOgre, "ID_GREATER_EQUAL", SWIG_From_int(static_cast< int >(Ogre::ID_GREATER_EQUAL)));
  rb_define_const(mOgre, "ID_GREATER", SWIG_From_int(static_cast< int >(Ogre::ID_GREATER)));
  rb_define_const(mOgre, "ID_ALPHA_REJECTION", SWIG_From_int(static_cast< int >(Ogre::ID_ALPHA_REJECTION)));
  rb_define_const(mOgre, "ID_ALPHA_TO_COVERAGE", SWIG_From_int(static_cast< int >(Ogre::ID_ALPHA_TO_COVERAGE)));
  rb_define_const(mOgre, "ID_LIGHT_SCISSOR", SWIG_From_int(static_cast< int >(Ogre::ID_LIGHT_SCISSOR)));
  rb_define_const(mOgre, "ID_LIGHT_CLIP_PLANES", SWIG_From_int(static_cast< int >(Ogre::ID_LIGHT_CLIP_PLANES)));
  rb_define_const(mOgre, "ID_TRANSPARENT_SORTING", SWIG_From_int(static_cast< int >(Ogre::ID_TRANSPARENT_SORTING)));
  rb_define_const(mOgre, "ID_ILLUMINATION_STAGE", SWIG_From_int(static_cast< int >(Ogre::ID_ILLUMINATION_STAGE)));
  rb_define_const(mOgre, "ID_DECAL", SWIG_From_int(static_cast< int >(Ogre::ID_DECAL)));
  rb_define_const(mOgre, "ID_CULL_HARDWARE", SWIG_From_int(static_cast< int >(Ogre::ID_CULL_HARDWARE)));
  rb_define_const(mOgre, "ID_CLOCKWISE", SWIG_From_int(static_cast< int >(Ogre::ID_CLOCKWISE)));
  rb_define_const(mOgre, "ID_ANTICLOCKWISE", SWIG_From_int(static_cast< int >(Ogre::ID_ANTICLOCKWISE)));
  rb_define_const(mOgre, "ID_CULL_SOFTWARE", SWIG_From_int(static_cast< int >(Ogre::ID_CULL_SOFTWARE)));
  rb_define_const(mOgre, "ID_BACK", SWIG_From_int(static_cast< int >(Ogre::ID_BACK)));
  rb_define_const(mOgre, "ID_FRONT", SWIG_From_int(static_cast< int >(Ogre::ID_FRONT)));
  rb_define_const(mOgre, "ID_NORMALISE_NORMALS", SWIG_From_int(static_cast< int >(Ogre::ID_NORMALISE_NORMALS)));
  rb_define_const(mOgre, "ID_LIGHTING", SWIG_From_int(static_cast< int >(Ogre::ID_LIGHTING)));
  rb_define_const(mOgre, "ID_SHADING", SWIG_From_int(static_cast< int >(Ogre::ID_SHADING)));
  rb_define_const(mOgre, "ID_FLAT", SWIG_From_int(static_cast< int >(Ogre::ID_FLAT)));
  rb_define_const(mOgre, "ID_GOURAUD", SWIG_From_int(static_cast< int >(Ogre::ID_GOURAUD)));
  rb_define_const(mOgre, "ID_PHONG", SWIG_From_int(static_cast< int >(Ogre::ID_PHONG)));
  rb_define_const(mOgre, "ID_POLYGON_MODE", SWIG_From_int(static_cast< int >(Ogre::ID_POLYGON_MODE)));
  rb_define_const(mOgre, "ID_SOLID", SWIG_From_int(static_cast< int >(Ogre::ID_SOLID)));
  rb_define_const(mOgre, "ID_WIREFRAME", SWIG_From_int(static_cast< int >(Ogre::ID_WIREFRAME)));
  rb_define_const(mOgre, "ID_POINTS", SWIG_From_int(static_cast< int >(Ogre::ID_POINTS)));
  rb_define_const(mOgre, "ID_POLYGON_MODE_OVERRIDEABLE", SWIG_From_int(static_cast< int >(Ogre::ID_POLYGON_MODE_OVERRIDEABLE)));
  rb_define_const(mOgre, "ID_FOG_OVERRIDE", SWIG_From_int(static_cast< int >(Ogre::ID_FOG_OVERRIDE)));
  rb_define_const(mOgre, "ID_NONE", SWIG_From_int(static_cast< int >(Ogre::ID_NONE)));
  rb_define_const(mOgre, "ID_LINEAR", SWIG_From_int(static_cast< int >(Ogre::ID_LINEAR)));
  rb_define_const(mOgre, "ID_EXP", SWIG_From_int(static_cast< int >(Ogre::ID_EXP)));
  rb_define_const(mOgre, "ID_EXP2", SWIG_From_int(static_cast< int >(Ogre::ID_EXP2)));
  rb_define_const(mOgre, "ID_COLOUR_WRITE", SWIG_From_int(static_cast< int >(Ogre::ID_COLOUR_WRITE)));
  rb_define_const(mOgre, "ID_MAX_LIGHTS", SWIG_From_int(static_cast< int >(Ogre::ID_MAX_LIGHTS)));
  rb_define_const(mOgre, "ID_START_LIGHT", SWIG_From_int(static_cast< int >(Ogre::ID_START_LIGHT)));
  rb_define_const(mOgre, "ID_ITERATION", SWIG_From_int(static_cast< int >(Ogre::ID_ITERATION)));
  rb_define_const(mOgre, "ID_ONCE", SWIG_From_int(static_cast< int >(Ogre::ID_ONCE)));
  rb_define_const(mOgre, "ID_ONCE_PER_LIGHT", SWIG_From_int(static_cast< int >(Ogre::ID_ONCE_PER_LIGHT)));
  rb_define_const(mOgre, "ID_PER_LIGHT", SWIG_From_int(static_cast< int >(Ogre::ID_PER_LIGHT)));
  rb_define_const(mOgre, "ID_PER_N_LIGHTS", SWIG_From_int(static_cast< int >(Ogre::ID_PER_N_LIGHTS)));
  rb_define_const(mOgre, "ID_POINT", SWIG_From_int(static_cast< int >(Ogre::ID_POINT)));
  rb_define_const(mOgre, "ID_SPOT", SWIG_From_int(static_cast< int >(Ogre::ID_SPOT)));
  rb_define_const(mOgre, "ID_DIRECTIONAL", SWIG_From_int(static_cast< int >(Ogre::ID_DIRECTIONAL)));
  rb_define_const(mOgre, "ID_LIGHT_MASK", SWIG_From_int(static_cast< int >(Ogre::ID_LIGHT_MASK)));
  rb_define_const(mOgre, "ID_POINT_SIZE", SWIG_From_int(static_cast< int >(Ogre::ID_POINT_SIZE)));
  rb_define_const(mOgre, "ID_POINT_SPRITES", SWIG_From_int(static_cast< int >(Ogre::ID_POINT_SPRITES)));
  rb_define_const(mOgre, "ID_POINT_SIZE_ATTENUATION", SWIG_From_int(static_cast< int >(Ogre::ID_POINT_SIZE_ATTENUATION)));
  rb_define_const(mOgre, "ID_POINT_SIZE_MIN", SWIG_From_int(static_cast< int >(Ogre::ID_POINT_SIZE_MIN)));
  rb_define_const(mOgre, "ID_POINT_SIZE_MAX", SWIG_From_int(static_cast< int >(Ogre::ID_POINT_SIZE_MAX)));
  rb_define_const(mOgre, "ID_TEXTURE_ALIAS", SWIG_From_int(static_cast< int >(Ogre::ID_TEXTURE_ALIAS)));
  rb_define_const(mOgre, "ID_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::ID_TEXTURE)));
  rb_define_const(mOgre, "ID_1D", SWIG_From_int(static_cast< int >(Ogre::ID_1D)));
  rb_define_const(mOgre, "ID_2D", SWIG_From_int(static_cast< int >(Ogre::ID_2D)));
  rb_define_const(mOgre, "ID_3D", SWIG_From_int(static_cast< int >(Ogre::ID_3D)));
  rb_define_const(mOgre, "ID_CUBIC", SWIG_From_int(static_cast< int >(Ogre::ID_CUBIC)));
  rb_define_const(mOgre, "ID_UNLIMITED", SWIG_From_int(static_cast< int >(Ogre::ID_UNLIMITED)));
  rb_define_const(mOgre, "ID_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_ALPHA)));
  rb_define_const(mOgre, "ID_GAMMA", SWIG_From_int(static_cast< int >(Ogre::ID_GAMMA)));
  rb_define_const(mOgre, "ID_ANIM_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::ID_ANIM_TEXTURE)));
  rb_define_const(mOgre, "ID_CUBIC_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::ID_CUBIC_TEXTURE)));
  rb_define_const(mOgre, "ID_SEPARATE_UV", SWIG_From_int(static_cast< int >(Ogre::ID_SEPARATE_UV)));
  rb_define_const(mOgre, "ID_COMBINED_UVW", SWIG_From_int(static_cast< int >(Ogre::ID_COMBINED_UVW)));
  rb_define_const(mOgre, "ID_TEX_COORD_SET", SWIG_From_int(static_cast< int >(Ogre::ID_TEX_COORD_SET)));
  rb_define_const(mOgre, "ID_TEX_ADDRESS_MODE", SWIG_From_int(static_cast< int >(Ogre::ID_TEX_ADDRESS_MODE)));
  rb_define_const(mOgre, "ID_WRAP", SWIG_From_int(static_cast< int >(Ogre::ID_WRAP)));
  rb_define_const(mOgre, "ID_CLAMP", SWIG_From_int(static_cast< int >(Ogre::ID_CLAMP)));
  rb_define_const(mOgre, "ID_BORDER", SWIG_From_int(static_cast< int >(Ogre::ID_BORDER)));
  rb_define_const(mOgre, "ID_MIRROR", SWIG_From_int(static_cast< int >(Ogre::ID_MIRROR)));
  rb_define_const(mOgre, "ID_TEX_BORDER_COLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_TEX_BORDER_COLOUR)));
  rb_define_const(mOgre, "ID_FILTERING", SWIG_From_int(static_cast< int >(Ogre::ID_FILTERING)));
  rb_define_const(mOgre, "ID_BILINEAR", SWIG_From_int(static_cast< int >(Ogre::ID_BILINEAR)));
  rb_define_const(mOgre, "ID_TRILINEAR", SWIG_From_int(static_cast< int >(Ogre::ID_TRILINEAR)));
  rb_define_const(mOgre, "ID_ANISOTROPIC", SWIG_From_int(static_cast< int >(Ogre::ID_ANISOTROPIC)));
  rb_define_const(mOgre, "ID_MAX_ANISOTROPY", SWIG_From_int(static_cast< int >(Ogre::ID_MAX_ANISOTROPY)));
  rb_define_const(mOgre, "ID_MIPMAP_BIAS", SWIG_From_int(static_cast< int >(Ogre::ID_MIPMAP_BIAS)));
  rb_define_const(mOgre, "ID_COLOUR_OP", SWIG_From_int(static_cast< int >(Ogre::ID_COLOUR_OP)));
  rb_define_const(mOgre, "ID_REPLACE", SWIG_From_int(static_cast< int >(Ogre::ID_REPLACE)));
  rb_define_const(mOgre, "ID_ADD", SWIG_From_int(static_cast< int >(Ogre::ID_ADD)));
  rb_define_const(mOgre, "ID_MODULATE", SWIG_From_int(static_cast< int >(Ogre::ID_MODULATE)));
  rb_define_const(mOgre, "ID_ALPHA_BLEND", SWIG_From_int(static_cast< int >(Ogre::ID_ALPHA_BLEND)));
  rb_define_const(mOgre, "ID_COLOUR_OP_EX", SWIG_From_int(static_cast< int >(Ogre::ID_COLOUR_OP_EX)));
  rb_define_const(mOgre, "ID_SOURCE1", SWIG_From_int(static_cast< int >(Ogre::ID_SOURCE1)));
  rb_define_const(mOgre, "ID_SOURCE2", SWIG_From_int(static_cast< int >(Ogre::ID_SOURCE2)));
  rb_define_const(mOgre, "ID_MODULATE_X2", SWIG_From_int(static_cast< int >(Ogre::ID_MODULATE_X2)));
  rb_define_const(mOgre, "ID_MODULATE_X4", SWIG_From_int(static_cast< int >(Ogre::ID_MODULATE_X4)));
  rb_define_const(mOgre, "ID_ADD_SIGNED", SWIG_From_int(static_cast< int >(Ogre::ID_ADD_SIGNED)));
  rb_define_const(mOgre, "ID_ADD_SMOOTH", SWIG_From_int(static_cast< int >(Ogre::ID_ADD_SMOOTH)));
  rb_define_const(mOgre, "ID_SUBTRACT", SWIG_From_int(static_cast< int >(Ogre::ID_SUBTRACT)));
  rb_define_const(mOgre, "ID_BLEND_DIFFUSE_COLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_BLEND_DIFFUSE_COLOUR)));
  rb_define_const(mOgre, "ID_BLEND_DIFFUSE_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_BLEND_DIFFUSE_ALPHA)));
  rb_define_const(mOgre, "ID_BLEND_TEXTURE_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_BLEND_TEXTURE_ALPHA)));
  rb_define_const(mOgre, "ID_BLEND_CURRENT_ALPHA", SWIG_From_int(static_cast< int >(Ogre::ID_BLEND_CURRENT_ALPHA)));
  rb_define_const(mOgre, "ID_BLEND_MANUAL", SWIG_From_int(static_cast< int >(Ogre::ID_BLEND_MANUAL)));
  rb_define_const(mOgre, "ID_DOT_PRODUCT", SWIG_From_int(static_cast< int >(Ogre::ID_DOT_PRODUCT)));
  rb_define_const(mOgre, "ID_SRC_CURRENT", SWIG_From_int(static_cast< int >(Ogre::ID_SRC_CURRENT)));
  rb_define_const(mOgre, "ID_SRC_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::ID_SRC_TEXTURE)));
  rb_define_const(mOgre, "ID_SRC_DIFFUSE", SWIG_From_int(static_cast< int >(Ogre::ID_SRC_DIFFUSE)));
  rb_define_const(mOgre, "ID_SRC_SPECULAR", SWIG_From_int(static_cast< int >(Ogre::ID_SRC_SPECULAR)));
  rb_define_const(mOgre, "ID_SRC_MANUAL", SWIG_From_int(static_cast< int >(Ogre::ID_SRC_MANUAL)));
  rb_define_const(mOgre, "ID_COLOUR_OP_MULTIPASS_FALLBACK", SWIG_From_int(static_cast< int >(Ogre::ID_COLOUR_OP_MULTIPASS_FALLBACK)));
  rb_define_const(mOgre, "ID_ALPHA_OP_EX", SWIG_From_int(static_cast< int >(Ogre::ID_ALPHA_OP_EX)));
  rb_define_const(mOgre, "ID_ENV_MAP", SWIG_From_int(static_cast< int >(Ogre::ID_ENV_MAP)));
  rb_define_const(mOgre, "ID_SPHERICAL", SWIG_From_int(static_cast< int >(Ogre::ID_SPHERICAL)));
  rb_define_const(mOgre, "ID_PLANAR", SWIG_From_int(static_cast< int >(Ogre::ID_PLANAR)));
  rb_define_const(mOgre, "ID_CUBIC_REFLECTION", SWIG_From_int(static_cast< int >(Ogre::ID_CUBIC_REFLECTION)));
  rb_define_const(mOgre, "ID_CUBIC_NORMAL", SWIG_From_int(static_cast< int >(Ogre::ID_CUBIC_NORMAL)));
  rb_define_const(mOgre, "ID_SCROLL", SWIG_From_int(static_cast< int >(Ogre::ID_SCROLL)));
  rb_define_const(mOgre, "ID_SCROLL_ANIM", SWIG_From_int(static_cast< int >(Ogre::ID_SCROLL_ANIM)));
  rb_define_const(mOgre, "ID_ROTATE", SWIG_From_int(static_cast< int >(Ogre::ID_ROTATE)));
  rb_define_const(mOgre, "ID_ROTATE_ANIM", SWIG_From_int(static_cast< int >(Ogre::ID_ROTATE_ANIM)));
  rb_define_const(mOgre, "ID_SCALE", SWIG_From_int(static_cast< int >(Ogre::ID_SCALE)));
  rb_define_const(mOgre, "ID_WAVE_XFORM", SWIG_From_int(static_cast< int >(Ogre::ID_WAVE_XFORM)));
  rb_define_const(mOgre, "ID_SCROLL_X", SWIG_From_int(static_cast< int >(Ogre::ID_SCROLL_X)));
  rb_define_const(mOgre, "ID_SCROLL_Y", SWIG_From_int(static_cast< int >(Ogre::ID_SCROLL_Y)));
  rb_define_const(mOgre, "ID_SCALE_X", SWIG_From_int(static_cast< int >(Ogre::ID_SCALE_X)));
  rb_define_const(mOgre, "ID_SCALE_Y", SWIG_From_int(static_cast< int >(Ogre::ID_SCALE_Y)));
  rb_define_const(mOgre, "ID_SINE", SWIG_From_int(static_cast< int >(Ogre::ID_SINE)));
  rb_define_const(mOgre, "ID_TRIANGLE", SWIG_From_int(static_cast< int >(Ogre::ID_TRIANGLE)));
  rb_define_const(mOgre, "ID_SQUARE", SWIG_From_int(static_cast< int >(Ogre::ID_SQUARE)));
  rb_define_const(mOgre, "ID_SAWTOOTH", SWIG_From_int(static_cast< int >(Ogre::ID_SAWTOOTH)));
  rb_define_const(mOgre, "ID_INVERSE_SAWTOOTH", SWIG_From_int(static_cast< int >(Ogre::ID_INVERSE_SAWTOOTH)));
  rb_define_const(mOgre, "ID_TRANSFORM", SWIG_From_int(static_cast< int >(Ogre::ID_TRANSFORM)));
  rb_define_const(mOgre, "ID_BINDING_TYPE", SWIG_From_int(static_cast< int >(Ogre::ID_BINDING_TYPE)));
  rb_define_const(mOgre, "ID_VERTEX", SWIG_From_int(static_cast< int >(Ogre::ID_VERTEX)));
  rb_define_const(mOgre, "ID_FRAGMENT", SWIG_From_int(static_cast< int >(Ogre::ID_FRAGMENT)));
  rb_define_const(mOgre, "ID_CONTENT_TYPE", SWIG_From_int(static_cast< int >(Ogre::ID_CONTENT_TYPE)));
  rb_define_const(mOgre, "ID_NAMED", SWIG_From_int(static_cast< int >(Ogre::ID_NAMED)));
  rb_define_const(mOgre, "ID_SHADOW", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOW)));
  rb_define_const(mOgre, "ID_TEXTURE_SOURCE", SWIG_From_int(static_cast< int >(Ogre::ID_TEXTURE_SOURCE)));
  rb_define_const(mOgre, "ID_SHARED_PARAMS", SWIG_From_int(static_cast< int >(Ogre::ID_SHARED_PARAMS)));
  rb_define_const(mOgre, "ID_SHARED_PARAM_NAMED", SWIG_From_int(static_cast< int >(Ogre::ID_SHARED_PARAM_NAMED)));
  rb_define_const(mOgre, "ID_SHARED_PARAMS_REF", SWIG_From_int(static_cast< int >(Ogre::ID_SHARED_PARAMS_REF)));
  rb_define_const(mOgre, "ID_PARTICLE_SYSTEM", SWIG_From_int(static_cast< int >(Ogre::ID_PARTICLE_SYSTEM)));
  rb_define_const(mOgre, "ID_EMITTER", SWIG_From_int(static_cast< int >(Ogre::ID_EMITTER)));
  rb_define_const(mOgre, "ID_AFFECTOR", SWIG_From_int(static_cast< int >(Ogre::ID_AFFECTOR)));
  rb_define_const(mOgre, "ID_COMPOSITOR", SWIG_From_int(static_cast< int >(Ogre::ID_COMPOSITOR)));
  rb_define_const(mOgre, "ID_TARGET", SWIG_From_int(static_cast< int >(Ogre::ID_TARGET)));
  rb_define_const(mOgre, "ID_TARGET_OUTPUT", SWIG_From_int(static_cast< int >(Ogre::ID_TARGET_OUTPUT)));
  rb_define_const(mOgre, "ID_INPUT", SWIG_From_int(static_cast< int >(Ogre::ID_INPUT)));
  rb_define_const(mOgre, "ID_PREVIOUS", SWIG_From_int(static_cast< int >(Ogre::ID_PREVIOUS)));
  rb_define_const(mOgre, "ID_TARGET_WIDTH", SWIG_From_int(static_cast< int >(Ogre::ID_TARGET_WIDTH)));
  rb_define_const(mOgre, "ID_TARGET_HEIGHT", SWIG_From_int(static_cast< int >(Ogre::ID_TARGET_HEIGHT)));
  rb_define_const(mOgre, "ID_TARGET_WIDTH_SCALED", SWIG_From_int(static_cast< int >(Ogre::ID_TARGET_WIDTH_SCALED)));
  rb_define_const(mOgre, "ID_TARGET_HEIGHT_SCALED", SWIG_From_int(static_cast< int >(Ogre::ID_TARGET_HEIGHT_SCALED)));
  rb_define_const(mOgre, "ID_COMPOSITOR_LOGIC", SWIG_From_int(static_cast< int >(Ogre::ID_COMPOSITOR_LOGIC)));
  rb_define_const(mOgre, "ID_TEXTURE_REF", SWIG_From_int(static_cast< int >(Ogre::ID_TEXTURE_REF)));
  rb_define_const(mOgre, "ID_SCOPE_LOCAL", SWIG_From_int(static_cast< int >(Ogre::ID_SCOPE_LOCAL)));
  rb_define_const(mOgre, "ID_SCOPE_CHAIN", SWIG_From_int(static_cast< int >(Ogre::ID_SCOPE_CHAIN)));
  rb_define_const(mOgre, "ID_SCOPE_GLOBAL", SWIG_From_int(static_cast< int >(Ogre::ID_SCOPE_GLOBAL)));
  rb_define_const(mOgre, "ID_POOLED", SWIG_From_int(static_cast< int >(Ogre::ID_POOLED)));
  rb_define_const(mOgre, "ID_NO_FSAA", SWIG_From_int(static_cast< int >(Ogre::ID_NO_FSAA)));
  rb_define_const(mOgre, "ID_DEPTH_POOL", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH_POOL)));
  rb_define_const(mOgre, "ID_ONLY_INITIAL", SWIG_From_int(static_cast< int >(Ogre::ID_ONLY_INITIAL)));
  rb_define_const(mOgre, "ID_VISIBILITY_MASK", SWIG_From_int(static_cast< int >(Ogre::ID_VISIBILITY_MASK)));
  rb_define_const(mOgre, "ID_LOD_BIAS", SWIG_From_int(static_cast< int >(Ogre::ID_LOD_BIAS)));
  rb_define_const(mOgre, "ID_MATERIAL_SCHEME", SWIG_From_int(static_cast< int >(Ogre::ID_MATERIAL_SCHEME)));
  rb_define_const(mOgre, "ID_SHADOWS_ENABLED", SWIG_From_int(static_cast< int >(Ogre::ID_SHADOWS_ENABLED)));
  rb_define_const(mOgre, "ID_CLEAR", SWIG_From_int(static_cast< int >(Ogre::ID_CLEAR)));
  rb_define_const(mOgre, "ID_STENCIL", SWIG_From_int(static_cast< int >(Ogre::ID_STENCIL)));
  rb_define_const(mOgre, "ID_RENDER_SCENE", SWIG_From_int(static_cast< int >(Ogre::ID_RENDER_SCENE)));
  rb_define_const(mOgre, "ID_RENDER_QUAD", SWIG_From_int(static_cast< int >(Ogre::ID_RENDER_QUAD)));
  rb_define_const(mOgre, "ID_IDENTIFIER", SWIG_From_int(static_cast< int >(Ogre::ID_IDENTIFIER)));
  rb_define_const(mOgre, "ID_FIRST_RENDER_QUEUE", SWIG_From_int(static_cast< int >(Ogre::ID_FIRST_RENDER_QUEUE)));
  rb_define_const(mOgre, "ID_LAST_RENDER_QUEUE", SWIG_From_int(static_cast< int >(Ogre::ID_LAST_RENDER_QUEUE)));
  rb_define_const(mOgre, "ID_QUAD_NORMALS", SWIG_From_int(static_cast< int >(Ogre::ID_QUAD_NORMALS)));
  rb_define_const(mOgre, "ID_CAMERA_FAR_CORNERS_VIEW_SPACE", SWIG_From_int(static_cast< int >(Ogre::ID_CAMERA_FAR_CORNERS_VIEW_SPACE)));
  rb_define_const(mOgre, "ID_CAMERA_FAR_CORNERS_WORLD_SPACE", SWIG_From_int(static_cast< int >(Ogre::ID_CAMERA_FAR_CORNERS_WORLD_SPACE)));
  rb_define_const(mOgre, "ID_BUFFERS", SWIG_From_int(static_cast< int >(Ogre::ID_BUFFERS)));
  rb_define_const(mOgre, "ID_COLOUR", SWIG_From_int(static_cast< int >(Ogre::ID_COLOUR)));
  rb_define_const(mOgre, "ID_DEPTH", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH)));
  rb_define_const(mOgre, "ID_COLOUR_VALUE", SWIG_From_int(static_cast< int >(Ogre::ID_COLOUR_VALUE)));
  rb_define_const(mOgre, "ID_DEPTH_VALUE", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH_VALUE)));
  rb_define_const(mOgre, "ID_STENCIL_VALUE", SWIG_From_int(static_cast< int >(Ogre::ID_STENCIL_VALUE)));
  rb_define_const(mOgre, "ID_CHECK", SWIG_From_int(static_cast< int >(Ogre::ID_CHECK)));
  rb_define_const(mOgre, "ID_COMP_FUNC", SWIG_From_int(static_cast< int >(Ogre::ID_COMP_FUNC)));
  rb_define_const(mOgre, "ID_REF_VALUE", SWIG_From_int(static_cast< int >(Ogre::ID_REF_VALUE)));
  rb_define_const(mOgre, "ID_MASK", SWIG_From_int(static_cast< int >(Ogre::ID_MASK)));
  rb_define_const(mOgre, "ID_FAIL_OP", SWIG_From_int(static_cast< int >(Ogre::ID_FAIL_OP)));
  rb_define_const(mOgre, "ID_KEEP", SWIG_From_int(static_cast< int >(Ogre::ID_KEEP)));
  rb_define_const(mOgre, "ID_INCREMENT", SWIG_From_int(static_cast< int >(Ogre::ID_INCREMENT)));
  rb_define_const(mOgre, "ID_DECREMENT", SWIG_From_int(static_cast< int >(Ogre::ID_DECREMENT)));
  rb_define_const(mOgre, "ID_INCREMENT_WRAP", SWIG_From_int(static_cast< int >(Ogre::ID_INCREMENT_WRAP)));
  rb_define_const(mOgre, "ID_DECREMENT_WRAP", SWIG_From_int(static_cast< int >(Ogre::ID_DECREMENT_WRAP)));
  rb_define_const(mOgre, "ID_INVERT", SWIG_From_int(static_cast< int >(Ogre::ID_INVERT)));
  rb_define_const(mOgre, "ID_DEPTH_FAIL_OP", SWIG_From_int(static_cast< int >(Ogre::ID_DEPTH_FAIL_OP)));
  rb_define_const(mOgre, "ID_PASS_OP", SWIG_From_int(static_cast< int >(Ogre::ID_PASS_OP)));
  rb_define_const(mOgre, "ID_TWO_SIDED", SWIG_From_int(static_cast< int >(Ogre::ID_TWO_SIDED)));
  rb_define_const(mOgre, "ID_RT_SHADER_SYSTEM", SWIG_From_int(static_cast< int >(Ogre::ID_RT_SHADER_SYSTEM)));
  rb_define_const(mOgre, "ID_END_BUILTIN_IDS", SWIG_From_int(static_cast< int >(Ogre::ID_END_BUILTIN_IDS)));
  
  SwigClassParticleSystem.klass = rb_define_class_under(mOgre, "ParticleSystem", ((swig_class *) SWIGTYPE_p_Ogre__StringInterface->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleSystem, (void *) &SwigClassParticleSystem);
  rb_define_alloc_func(SwigClassParticleSystem.klass, _wrap_ParticleSystem_allocate);
  rb_define_method(SwigClassParticleSystem.klass, "initialize", VALUEFUNC(_wrap_new_ParticleSystem), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setRenderer", VALUEFUNC(_wrap_ParticleSystem_setRenderer), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getRenderer", VALUEFUNC(_wrap_ParticleSystem_getRenderer), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getRendererName", VALUEFUNC(_wrap_ParticleSystem_getRendererName), -1);
  rb_define_method(SwigClassParticleSystem.klass, "addEmitter", VALUEFUNC(_wrap_ParticleSystem_addEmitter), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getEmitter", VALUEFUNC(_wrap_ParticleSystem_getEmitter), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getNumEmitters", VALUEFUNC(_wrap_ParticleSystem_getNumEmitters), -1);
  rb_define_method(SwigClassParticleSystem.klass, "removeEmitter", VALUEFUNC(_wrap_ParticleSystem_removeEmitter), -1);
  rb_define_method(SwigClassParticleSystem.klass, "removeAllEmitters", VALUEFUNC(_wrap_ParticleSystem_removeAllEmitters), -1);
  rb_define_method(SwigClassParticleSystem.klass, "addAffector", VALUEFUNC(_wrap_ParticleSystem_addAffector), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getAffector", VALUEFUNC(_wrap_ParticleSystem_getAffector), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getNumAffectors", VALUEFUNC(_wrap_ParticleSystem_getNumAffectors), -1);
  rb_define_method(SwigClassParticleSystem.klass, "removeAffector", VALUEFUNC(_wrap_ParticleSystem_removeAffector), -1);
  rb_define_method(SwigClassParticleSystem.klass, "removeAllAffectors", VALUEFUNC(_wrap_ParticleSystem_removeAllAffectors), -1);
  rb_define_method(SwigClassParticleSystem.klass, "clear", VALUEFUNC(_wrap_ParticleSystem_clear), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getNumParticles", VALUEFUNC(_wrap_ParticleSystem_getNumParticles), -1);
  rb_define_method(SwigClassParticleSystem.klass, "createParticle", VALUEFUNC(_wrap_ParticleSystem_createParticle), -1);
  rb_define_method(SwigClassParticleSystem.klass, "createEmitterParticle", VALUEFUNC(_wrap_ParticleSystem_createEmitterParticle), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getParticle", VALUEFUNC(_wrap_ParticleSystem_getParticle), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getParticleQuota", VALUEFUNC(_wrap_ParticleSystem_getParticleQuota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setParticleQuota", VALUEFUNC(_wrap_ParticleSystem_setParticleQuota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getEmittedEmitterQuota", VALUEFUNC(_wrap_ParticleSystem_getEmittedEmitterQuota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setEmittedEmitterQuota", VALUEFUNC(_wrap_ParticleSystem_setEmittedEmitterQuota), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_update", VALUEFUNC(_wrap_ParticleSystem__update), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_getIterator", VALUEFUNC(_wrap_ParticleSystem__getIterator), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setMaterialName", VALUEFUNC(_wrap_ParticleSystem_setMaterialName), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getMaterialName", VALUEFUNC(_wrap_ParticleSystem_getMaterialName), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notifyCurrentCamera", VALUEFUNC(_wrap_ParticleSystem__notifyCurrentCamera), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notifyAttached", VALUEFUNC(_wrap_ParticleSystem__notifyAttached), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getBoundingBox", VALUEFUNC(_wrap_ParticleSystem_getBoundingBox), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getBoundingRadius", VALUEFUNC(_wrap_ParticleSystem_getBoundingRadius), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_updateRenderQueue", VALUEFUNC(_wrap_ParticleSystem__updateRenderQueue), -1);
  rb_define_method(SwigClassParticleSystem.klass, "visitRenderables", VALUEFUNC(_wrap_ParticleSystem_visitRenderables), -1);
  rb_define_method(SwigClassParticleSystem.klass, "fastForward", VALUEFUNC(_wrap_ParticleSystem_fastForward), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setSpeedFactor", VALUEFUNC(_wrap_ParticleSystem_setSpeedFactor), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getSpeedFactor", VALUEFUNC(_wrap_ParticleSystem_getSpeedFactor), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setIterationInterval", VALUEFUNC(_wrap_ParticleSystem_setIterationInterval), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getIterationInterval", VALUEFUNC(_wrap_ParticleSystem_getIterationInterval), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "setDefaultIterationInterval", VALUEFUNC(_wrap_ParticleSystem_setDefaultIterationInterval), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "getDefaultIterationInterval", VALUEFUNC(_wrap_ParticleSystem_getDefaultIterationInterval), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setNonVisibleUpdateTimeout", VALUEFUNC(_wrap_ParticleSystem_setNonVisibleUpdateTimeout), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getNonVisibleUpdateTimeout", VALUEFUNC(_wrap_ParticleSystem_getNonVisibleUpdateTimeout), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "setDefaultNonVisibleUpdateTimeout", VALUEFUNC(_wrap_ParticleSystem_setDefaultNonVisibleUpdateTimeout), -1);
  rb_define_singleton_method(SwigClassParticleSystem.klass, "getDefaultNonVisibleUpdateTimeout", VALUEFUNC(_wrap_ParticleSystem_getDefaultNonVisibleUpdateTimeout), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getMovableType", VALUEFUNC(_wrap_ParticleSystem_getMovableType), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notifyParticleResized", VALUEFUNC(_wrap_ParticleSystem__notifyParticleResized), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notifyParticleRotated", VALUEFUNC(_wrap_ParticleSystem__notifyParticleRotated), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setDefaultDimensions", VALUEFUNC(_wrap_ParticleSystem_setDefaultDimensions), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setDefaultWidth", VALUEFUNC(_wrap_ParticleSystem_setDefaultWidth), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getDefaultWidth", VALUEFUNC(_wrap_ParticleSystem_getDefaultWidth), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setDefaultHeight", VALUEFUNC(_wrap_ParticleSystem_setDefaultHeight), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getDefaultHeight", VALUEFUNC(_wrap_ParticleSystem_getDefaultHeight), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getCullIndividually", VALUEFUNC(_wrap_ParticleSystem_getCullIndividually), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setCullIndividually", VALUEFUNC(_wrap_ParticleSystem_setCullIndividually), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getResourceGroupName", VALUEFUNC(_wrap_ParticleSystem_getResourceGroupName), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getOrigin", VALUEFUNC(_wrap_ParticleSystem_getOrigin), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_notifyOrigin", VALUEFUNC(_wrap_ParticleSystem__notifyOrigin), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_ParticleSystem_setRenderQueueGroup), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setSortingEnabled", VALUEFUNC(_wrap_ParticleSystem_setSortingEnabled), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getSortingEnabled", VALUEFUNC(_wrap_ParticleSystem_getSortingEnabled), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setBounds", VALUEFUNC(_wrap_ParticleSystem_setBounds), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setBoundsAutoUpdated", VALUEFUNC(_wrap_ParticleSystem_setBoundsAutoUpdated), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setKeepParticlesInLocalSpace", VALUEFUNC(_wrap_ParticleSystem_setKeepParticlesInLocalSpace), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getKeepParticlesInLocalSpace", VALUEFUNC(_wrap_ParticleSystem_getKeepParticlesInLocalSpace), -1);
  rb_define_method(SwigClassParticleSystem.klass, "_updateBounds", VALUEFUNC(_wrap_ParticleSystem__updateBounds), -1);
  rb_define_method(SwigClassParticleSystem.klass, "setEmitting", VALUEFUNC(_wrap_ParticleSystem_setEmitting), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getEmitting", VALUEFUNC(_wrap_ParticleSystem_getEmitting), -1);
  rb_define_method(SwigClassParticleSystem.klass, "getTypeFlags", VALUEFUNC(_wrap_ParticleSystem_getTypeFlags), -1);
  SwigClassParticleSystem.mark = 0;
  SwigClassParticleSystem.destroy = (void (*)(void *)) free_Ogre_ParticleSystem;
  SwigClassParticleSystem.trackObjects = 0;
  
  SwigClassParticleSystemManager.klass = rb_define_class_under(mOgre, "ParticleSystemManager", ((swig_class *) SWIGTYPE_p_Ogre__ScriptLoader->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleSystemManager, (void *) &SwigClassParticleSystemManager);
  rb_define_alloc_func(SwigClassParticleSystemManager.klass, _wrap_ParticleSystemManager_allocate);
  rb_define_method(SwigClassParticleSystemManager.klass, "initialize", VALUEFUNC(_wrap_new_ParticleSystemManager), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "addEmitterFactory", VALUEFUNC(_wrap_ParticleSystemManager_addEmitterFactory), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "addAffectorFactory", VALUEFUNC(_wrap_ParticleSystemManager_addAffectorFactory), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "addRendererFactory", VALUEFUNC(_wrap_ParticleSystemManager_addRendererFactory), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "addTemplate", VALUEFUNC(_wrap_ParticleSystemManager_addTemplate), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "removeTemplate", VALUEFUNC(_wrap_ParticleSystemManager_removeTemplate), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "removeAllTemplates", VALUEFUNC(_wrap_ParticleSystemManager_removeAllTemplates), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "removeTemplatesByResourceGroup", VALUEFUNC(_wrap_ParticleSystemManager_removeTemplatesByResourceGroup), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "createTemplate", VALUEFUNC(_wrap_ParticleSystemManager_createTemplate), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "getTemplate", VALUEFUNC(_wrap_ParticleSystemManager_getTemplate), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_createEmitter", VALUEFUNC(_wrap_ParticleSystemManager__createEmitter), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_destroyEmitter", VALUEFUNC(_wrap_ParticleSystemManager__destroyEmitter), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_createAffector", VALUEFUNC(_wrap_ParticleSystemManager__createAffector), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_destroyAffector", VALUEFUNC(_wrap_ParticleSystemManager__destroyAffector), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_createRenderer", VALUEFUNC(_wrap_ParticleSystemManager__createRenderer), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_destroyRenderer", VALUEFUNC(_wrap_ParticleSystemManager__destroyRenderer), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_initialise", VALUEFUNC(_wrap_ParticleSystemManager__initialise), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "getScriptPatterns", VALUEFUNC(_wrap_ParticleSystemManager_getScriptPatterns), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "parseScript", VALUEFUNC(_wrap_ParticleSystemManager_parseScript), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "getLoadingOrder", VALUEFUNC(_wrap_ParticleSystemManager_getLoadingOrder), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "getAffectorFactoryIterator", VALUEFUNC(_wrap_ParticleSystemManager_getAffectorFactoryIterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "getEmitterFactoryIterator", VALUEFUNC(_wrap_ParticleSystemManager_getEmitterFactoryIterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "getRendererFactoryIterator", VALUEFUNC(_wrap_ParticleSystemManager_getRendererFactoryIterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "getTemplateIterator", VALUEFUNC(_wrap_ParticleSystemManager_getTemplateIterator), -1);
  rb_define_method(SwigClassParticleSystemManager.klass, "_getFactory", VALUEFUNC(_wrap_ParticleSystemManager__getFactory), -1);
  rb_define_singleton_method(SwigClassParticleSystemManager.klass, "getSingleton", VALUEFUNC(_wrap_ParticleSystemManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassParticleSystemManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_ParticleSystemManager_getSingletonPtr), -1);
  SwigClassParticleSystemManager.mark = 0;
  SwigClassParticleSystemManager.destroy = (void (*)(void *)) free_Ogre_ParticleSystemManager;
  SwigClassParticleSystemManager.trackObjects = 0;
  
  SwigClassParticleSystemFactory.klass = rb_define_class_under(mOgre, "ParticleSystemFactory", ((swig_class *) SWIGTYPE_p_Ogre__MovableObjectFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleSystemFactory, (void *) &SwigClassParticleSystemFactory);
  rb_undef_alloc_func(SwigClassParticleSystemFactory.klass);
  rb_define_singleton_method(SwigClassParticleSystemFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_ParticleSystemFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_singleton_method(SwigClassParticleSystemFactory.klass, "FACTORY_TYPE_NAME=", VALUEFUNC(_wrap_ParticleSystemFactory_FACTORY_TYPE_NAME_set), 1);
  rb_define_method(SwigClassParticleSystemFactory.klass, "getType", VALUEFUNC(_wrap_ParticleSystemFactory_getType), -1);
  rb_define_method(SwigClassParticleSystemFactory.klass, "destroyInstance", VALUEFUNC(_wrap_ParticleSystemFactory_destroyInstance), -1);
  SwigClassParticleSystemFactory.mark = 0;
  SwigClassParticleSystemFactory.destroy = (void (*)(void *)) free_Ogre_ParticleSystemFactory;
  SwigClassParticleSystemFactory.trackObjects = 0;
  rb_define_const(mOgre, "IS_AMBIENT", SWIG_From_int(static_cast< int >(Ogre::IS_AMBIENT)));
  rb_define_const(mOgre, "IS_PER_LIGHT", SWIG_From_int(static_cast< int >(Ogre::IS_PER_LIGHT)));
  rb_define_const(mOgre, "IS_DECAL", SWIG_From_int(static_cast< int >(Ogre::IS_DECAL)));
  rb_define_const(mOgre, "IS_UNKNOWN", SWIG_From_int(static_cast< int >(Ogre::IS_UNKNOWN)));
  
  SwigClassPass.klass = rb_define_class_under(mOgre, "Pass", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Pass, (void *) &SwigClassPass);
  rb_define_alloc_func(SwigClassPass.klass, _wrap_Pass_allocate);
  rb_define_method(SwigClassPass.klass, "initialize", VALUEFUNC(_wrap_new_Pass), -1);
  rb_define_method(SwigClassPass.klass, "isProgrammable", VALUEFUNC(_wrap_Pass_isProgrammable), -1);
  rb_define_method(SwigClassPass.klass, "hasVertexProgram", VALUEFUNC(_wrap_Pass_hasVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "hasFragmentProgram", VALUEFUNC(_wrap_Pass_hasFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "hasGeometryProgram", VALUEFUNC(_wrap_Pass_hasGeometryProgram), -1);
  rb_define_method(SwigClassPass.klass, "hasShadowCasterVertexProgram", VALUEFUNC(_wrap_Pass_hasShadowCasterVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "hasShadowCasterFragmentProgram", VALUEFUNC(_wrap_Pass_hasShadowCasterFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "hasShadowReceiverVertexProgram", VALUEFUNC(_wrap_Pass_hasShadowReceiverVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "hasShadowReceiverFragmentProgram", VALUEFUNC(_wrap_Pass_hasShadowReceiverFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "getIndex", VALUEFUNC(_wrap_Pass_getIndex), -1);
  rb_define_method(SwigClassPass.klass, "setName", VALUEFUNC(_wrap_Pass_setName), -1);
  rb_define_method(SwigClassPass.klass, "getName", VALUEFUNC(_wrap_Pass_getName), -1);
  rb_define_method(SwigClassPass.klass, "setAmbient", VALUEFUNC(_wrap_Pass_setAmbient), -1);
  rb_define_method(SwigClassPass.klass, "setDiffuse", VALUEFUNC(_wrap_Pass_setDiffuse), -1);
  rb_define_method(SwigClassPass.klass, "setSpecular", VALUEFUNC(_wrap_Pass_setSpecular), -1);
  rb_define_method(SwigClassPass.klass, "setShininess", VALUEFUNC(_wrap_Pass_setShininess), -1);
  rb_define_method(SwigClassPass.klass, "setSelfIllumination", VALUEFUNC(_wrap_Pass_setSelfIllumination), -1);
  rb_define_method(SwigClassPass.klass, "setEmissive", VALUEFUNC(_wrap_Pass_setEmissive), -1);
  rb_define_method(SwigClassPass.klass, "setVertexColourTracking", VALUEFUNC(_wrap_Pass_setVertexColourTracking), -1);
  rb_define_method(SwigClassPass.klass, "getPointSize", VALUEFUNC(_wrap_Pass_getPointSize), -1);
  rb_define_method(SwigClassPass.klass, "setPointSize", VALUEFUNC(_wrap_Pass_setPointSize), -1);
  rb_define_method(SwigClassPass.klass, "setPointSpritesEnabled", VALUEFUNC(_wrap_Pass_setPointSpritesEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getPointSpritesEnabled", VALUEFUNC(_wrap_Pass_getPointSpritesEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setPointAttenuation", VALUEFUNC(_wrap_Pass_setPointAttenuation), -1);
  rb_define_method(SwigClassPass.klass, "isPointAttenuationEnabled", VALUEFUNC(_wrap_Pass_isPointAttenuationEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getPointAttenuationConstant", VALUEFUNC(_wrap_Pass_getPointAttenuationConstant), -1);
  rb_define_method(SwigClassPass.klass, "getPointAttenuationLinear", VALUEFUNC(_wrap_Pass_getPointAttenuationLinear), -1);
  rb_define_method(SwigClassPass.klass, "getPointAttenuationQuadratic", VALUEFUNC(_wrap_Pass_getPointAttenuationQuadratic), -1);
  rb_define_method(SwigClassPass.klass, "setPointMinSize", VALUEFUNC(_wrap_Pass_setPointMinSize), -1);
  rb_define_method(SwigClassPass.klass, "getPointMinSize", VALUEFUNC(_wrap_Pass_getPointMinSize), -1);
  rb_define_method(SwigClassPass.klass, "setPointMaxSize", VALUEFUNC(_wrap_Pass_setPointMaxSize), -1);
  rb_define_method(SwigClassPass.klass, "getPointMaxSize", VALUEFUNC(_wrap_Pass_getPointMaxSize), -1);
  rb_define_method(SwigClassPass.klass, "getAmbient", VALUEFUNC(_wrap_Pass_getAmbient), -1);
  rb_define_method(SwigClassPass.klass, "getDiffuse", VALUEFUNC(_wrap_Pass_getDiffuse), -1);
  rb_define_method(SwigClassPass.klass, "getSpecular", VALUEFUNC(_wrap_Pass_getSpecular), -1);
  rb_define_method(SwigClassPass.klass, "getSelfIllumination", VALUEFUNC(_wrap_Pass_getSelfIllumination), -1);
  rb_define_method(SwigClassPass.klass, "getEmissive", VALUEFUNC(_wrap_Pass_getEmissive), -1);
  rb_define_method(SwigClassPass.klass, "getShininess", VALUEFUNC(_wrap_Pass_getShininess), -1);
  rb_define_method(SwigClassPass.klass, "getVertexColourTracking", VALUEFUNC(_wrap_Pass_getVertexColourTracking), -1);
  rb_define_method(SwigClassPass.klass, "createTextureUnitState", VALUEFUNC(_wrap_Pass_createTextureUnitState), -1);
  rb_define_method(SwigClassPass.klass, "addTextureUnitState", VALUEFUNC(_wrap_Pass_addTextureUnitState), -1);
  rb_define_method(SwigClassPass.klass, "getTextureUnitState", VALUEFUNC(_wrap_Pass_getTextureUnitState), -1);
  rb_define_method(SwigClassPass.klass, "getTextureUnitStateIndex", VALUEFUNC(_wrap_Pass_getTextureUnitStateIndex), -1);
  rb_define_method(SwigClassPass.klass, "getTextureUnitStateIterator", VALUEFUNC(_wrap_Pass_getTextureUnitStateIterator), -1);
  rb_define_method(SwigClassPass.klass, "removeTextureUnitState", VALUEFUNC(_wrap_Pass_removeTextureUnitState), -1);
  rb_define_method(SwigClassPass.klass, "removeAllTextureUnitStates", VALUEFUNC(_wrap_Pass_removeAllTextureUnitStates), -1);
  rb_define_method(SwigClassPass.klass, "getNumTextureUnitStates", VALUEFUNC(_wrap_Pass_getNumTextureUnitStates), -1);
  rb_define_method(SwigClassPass.klass, "setSceneBlending", VALUEFUNC(_wrap_Pass_setSceneBlending), -1);
  rb_define_method(SwigClassPass.klass, "setSeparateSceneBlending", VALUEFUNC(_wrap_Pass_setSeparateSceneBlending), -1);
  rb_define_method(SwigClassPass.klass, "hasSeparateSceneBlending", VALUEFUNC(_wrap_Pass_hasSeparateSceneBlending), -1);
  rb_define_method(SwigClassPass.klass, "getSourceBlendFactor", VALUEFUNC(_wrap_Pass_getSourceBlendFactor), -1);
  rb_define_method(SwigClassPass.klass, "getDestBlendFactor", VALUEFUNC(_wrap_Pass_getDestBlendFactor), -1);
  rb_define_method(SwigClassPass.klass, "getSourceBlendFactorAlpha", VALUEFUNC(_wrap_Pass_getSourceBlendFactorAlpha), -1);
  rb_define_method(SwigClassPass.klass, "getDestBlendFactorAlpha", VALUEFUNC(_wrap_Pass_getDestBlendFactorAlpha), -1);
  rb_define_method(SwigClassPass.klass, "setSceneBlendingOperation", VALUEFUNC(_wrap_Pass_setSceneBlendingOperation), -1);
  rb_define_method(SwigClassPass.klass, "setSeparateSceneBlendingOperation", VALUEFUNC(_wrap_Pass_setSeparateSceneBlendingOperation), -1);
  rb_define_method(SwigClassPass.klass, "hasSeparateSceneBlendingOperations", VALUEFUNC(_wrap_Pass_hasSeparateSceneBlendingOperations), -1);
  rb_define_method(SwigClassPass.klass, "getSceneBlendingOperation", VALUEFUNC(_wrap_Pass_getSceneBlendingOperation), -1);
  rb_define_method(SwigClassPass.klass, "getSceneBlendingOperationAlpha", VALUEFUNC(_wrap_Pass_getSceneBlendingOperationAlpha), -1);
  rb_define_method(SwigClassPass.klass, "isTransparent", VALUEFUNC(_wrap_Pass_isTransparent), -1);
  rb_define_method(SwigClassPass.klass, "setDepthCheckEnabled", VALUEFUNC(_wrap_Pass_setDepthCheckEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getDepthCheckEnabled", VALUEFUNC(_wrap_Pass_getDepthCheckEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setDepthWriteEnabled", VALUEFUNC(_wrap_Pass_setDepthWriteEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getDepthWriteEnabled", VALUEFUNC(_wrap_Pass_getDepthWriteEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setDepthFunction", VALUEFUNC(_wrap_Pass_setDepthFunction), -1);
  rb_define_method(SwigClassPass.klass, "getDepthFunction", VALUEFUNC(_wrap_Pass_getDepthFunction), -1);
  rb_define_method(SwigClassPass.klass, "setColourWriteEnabled", VALUEFUNC(_wrap_Pass_setColourWriteEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getColourWriteEnabled", VALUEFUNC(_wrap_Pass_getColourWriteEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setCullingMode", VALUEFUNC(_wrap_Pass_setCullingMode), -1);
  rb_define_method(SwigClassPass.klass, "getCullingMode", VALUEFUNC(_wrap_Pass_getCullingMode), -1);
  rb_define_method(SwigClassPass.klass, "setManualCullingMode", VALUEFUNC(_wrap_Pass_setManualCullingMode), -1);
  rb_define_method(SwigClassPass.klass, "getManualCullingMode", VALUEFUNC(_wrap_Pass_getManualCullingMode), -1);
  rb_define_method(SwigClassPass.klass, "setLightingEnabled", VALUEFUNC(_wrap_Pass_setLightingEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getLightingEnabled", VALUEFUNC(_wrap_Pass_getLightingEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setMaxSimultaneousLights", VALUEFUNC(_wrap_Pass_setMaxSimultaneousLights), -1);
  rb_define_method(SwigClassPass.klass, "getMaxSimultaneousLights", VALUEFUNC(_wrap_Pass_getMaxSimultaneousLights), -1);
  rb_define_method(SwigClassPass.klass, "setStartLight", VALUEFUNC(_wrap_Pass_setStartLight), -1);
  rb_define_method(SwigClassPass.klass, "getStartLight", VALUEFUNC(_wrap_Pass_getStartLight), -1);
  rb_define_method(SwigClassPass.klass, "setLightMask", VALUEFUNC(_wrap_Pass_setLightMask), -1);
  rb_define_method(SwigClassPass.klass, "getLightMask", VALUEFUNC(_wrap_Pass_getLightMask), -1);
  rb_define_method(SwigClassPass.klass, "setShadingMode", VALUEFUNC(_wrap_Pass_setShadingMode), -1);
  rb_define_method(SwigClassPass.klass, "getShadingMode", VALUEFUNC(_wrap_Pass_getShadingMode), -1);
  rb_define_method(SwigClassPass.klass, "setPolygonMode", VALUEFUNC(_wrap_Pass_setPolygonMode), -1);
  rb_define_method(SwigClassPass.klass, "getPolygonMode", VALUEFUNC(_wrap_Pass_getPolygonMode), -1);
  rb_define_method(SwigClassPass.klass, "setPolygonModeOverrideable", VALUEFUNC(_wrap_Pass_setPolygonModeOverrideable), -1);
  rb_define_method(SwigClassPass.klass, "getPolygonModeOverrideable", VALUEFUNC(_wrap_Pass_getPolygonModeOverrideable), -1);
  rb_define_method(SwigClassPass.klass, "setFog", VALUEFUNC(_wrap_Pass_setFog), -1);
  rb_define_method(SwigClassPass.klass, "getFogOverride", VALUEFUNC(_wrap_Pass_getFogOverride), -1);
  rb_define_method(SwigClassPass.klass, "getFogMode", VALUEFUNC(_wrap_Pass_getFogMode), -1);
  rb_define_method(SwigClassPass.klass, "getFogColour", VALUEFUNC(_wrap_Pass_getFogColour), -1);
  rb_define_method(SwigClassPass.klass, "getFogStart", VALUEFUNC(_wrap_Pass_getFogStart), -1);
  rb_define_method(SwigClassPass.klass, "getFogEnd", VALUEFUNC(_wrap_Pass_getFogEnd), -1);
  rb_define_method(SwigClassPass.klass, "getFogDensity", VALUEFUNC(_wrap_Pass_getFogDensity), -1);
  rb_define_method(SwigClassPass.klass, "setDepthBias", VALUEFUNC(_wrap_Pass_setDepthBias), -1);
  rb_define_method(SwigClassPass.klass, "getDepthBiasConstant", VALUEFUNC(_wrap_Pass_getDepthBiasConstant), -1);
  rb_define_method(SwigClassPass.klass, "getDepthBiasSlopeScale", VALUEFUNC(_wrap_Pass_getDepthBiasSlopeScale), -1);
  rb_define_method(SwigClassPass.klass, "setIterationDepthBias", VALUEFUNC(_wrap_Pass_setIterationDepthBias), -1);
  rb_define_method(SwigClassPass.klass, "getIterationDepthBias", VALUEFUNC(_wrap_Pass_getIterationDepthBias), -1);
  rb_define_method(SwigClassPass.klass, "setAlphaRejectSettings", VALUEFUNC(_wrap_Pass_setAlphaRejectSettings), -1);
  rb_define_method(SwigClassPass.klass, "setAlphaRejectFunction", VALUEFUNC(_wrap_Pass_setAlphaRejectFunction), -1);
  rb_define_method(SwigClassPass.klass, "setAlphaRejectValue", VALUEFUNC(_wrap_Pass_setAlphaRejectValue), -1);
  rb_define_method(SwigClassPass.klass, "getAlphaRejectFunction", VALUEFUNC(_wrap_Pass_getAlphaRejectFunction), -1);
  rb_define_method(SwigClassPass.klass, "getAlphaRejectValue", VALUEFUNC(_wrap_Pass_getAlphaRejectValue), -1);
  rb_define_method(SwigClassPass.klass, "setAlphaToCoverageEnabled", VALUEFUNC(_wrap_Pass_setAlphaToCoverageEnabled), -1);
  rb_define_method(SwigClassPass.klass, "isAlphaToCoverageEnabled", VALUEFUNC(_wrap_Pass_isAlphaToCoverageEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setTransparentSortingEnabled", VALUEFUNC(_wrap_Pass_setTransparentSortingEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getTransparentSortingEnabled", VALUEFUNC(_wrap_Pass_getTransparentSortingEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setTransparentSortingForced", VALUEFUNC(_wrap_Pass_setTransparentSortingForced), -1);
  rb_define_method(SwigClassPass.klass, "getTransparentSortingForced", VALUEFUNC(_wrap_Pass_getTransparentSortingForced), -1);
  rb_define_method(SwigClassPass.klass, "setIteratePerLight", VALUEFUNC(_wrap_Pass_setIteratePerLight), -1);
  rb_define_method(SwigClassPass.klass, "getIteratePerLight", VALUEFUNC(_wrap_Pass_getIteratePerLight), -1);
  rb_define_method(SwigClassPass.klass, "getRunOnlyForOneLightType", VALUEFUNC(_wrap_Pass_getRunOnlyForOneLightType), -1);
  rb_define_method(SwigClassPass.klass, "getOnlyLightType", VALUEFUNC(_wrap_Pass_getOnlyLightType), -1);
  rb_define_method(SwigClassPass.klass, "setLightCountPerIteration", VALUEFUNC(_wrap_Pass_setLightCountPerIteration), -1);
  rb_define_method(SwigClassPass.klass, "getLightCountPerIteration", VALUEFUNC(_wrap_Pass_getLightCountPerIteration), -1);
  rb_define_method(SwigClassPass.klass, "getParent", VALUEFUNC(_wrap_Pass_getParent), -1);
  rb_define_method(SwigClassPass.klass, "getResourceGroup", VALUEFUNC(_wrap_Pass_getResourceGroup), -1);
  rb_define_method(SwigClassPass.klass, "setVertexProgram", VALUEFUNC(_wrap_Pass_setVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "setVertexProgramParameters", VALUEFUNC(_wrap_Pass_setVertexProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getVertexProgramName", VALUEFUNC(_wrap_Pass_getVertexProgramName), -1);
  rb_define_method(SwigClassPass.klass, "getVertexProgramParameters", VALUEFUNC(_wrap_Pass_getVertexProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getVertexProgram", VALUEFUNC(_wrap_Pass_getVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "setShadowCasterVertexProgram", VALUEFUNC(_wrap_Pass_setShadowCasterVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "setShadowCasterVertexProgramParameters", VALUEFUNC(_wrap_Pass_setShadowCasterVertexProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getShadowCasterVertexProgramName", VALUEFUNC(_wrap_Pass_getShadowCasterVertexProgramName), -1);
  rb_define_method(SwigClassPass.klass, "getShadowCasterVertexProgramParameters", VALUEFUNC(_wrap_Pass_getShadowCasterVertexProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getShadowCasterVertexProgram", VALUEFUNC(_wrap_Pass_getShadowCasterVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "setShadowCasterFragmentProgram", VALUEFUNC(_wrap_Pass_setShadowCasterFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "setShadowCasterFragmentProgramParameters", VALUEFUNC(_wrap_Pass_setShadowCasterFragmentProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getShadowCasterFragmentProgramName", VALUEFUNC(_wrap_Pass_getShadowCasterFragmentProgramName), -1);
  rb_define_method(SwigClassPass.klass, "getShadowCasterFragmentProgramParameters", VALUEFUNC(_wrap_Pass_getShadowCasterFragmentProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getShadowCasterFragmentProgram", VALUEFUNC(_wrap_Pass_getShadowCasterFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "setShadowReceiverVertexProgram", VALUEFUNC(_wrap_Pass_setShadowReceiverVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "setShadowReceiverVertexProgramParameters", VALUEFUNC(_wrap_Pass_setShadowReceiverVertexProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "setShadowReceiverFragmentProgram", VALUEFUNC(_wrap_Pass_setShadowReceiverFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "setShadowReceiverFragmentProgramParameters", VALUEFUNC(_wrap_Pass_setShadowReceiverFragmentProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getShadowReceiverVertexProgramName", VALUEFUNC(_wrap_Pass_getShadowReceiverVertexProgramName), -1);
  rb_define_method(SwigClassPass.klass, "getShadowReceiverVertexProgramParameters", VALUEFUNC(_wrap_Pass_getShadowReceiverVertexProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getShadowReceiverVertexProgram", VALUEFUNC(_wrap_Pass_getShadowReceiverVertexProgram), -1);
  rb_define_method(SwigClassPass.klass, "getShadowReceiverFragmentProgramName", VALUEFUNC(_wrap_Pass_getShadowReceiverFragmentProgramName), -1);
  rb_define_method(SwigClassPass.klass, "getShadowReceiverFragmentProgramParameters", VALUEFUNC(_wrap_Pass_getShadowReceiverFragmentProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getShadowReceiverFragmentProgram", VALUEFUNC(_wrap_Pass_getShadowReceiverFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "setFragmentProgram", VALUEFUNC(_wrap_Pass_setFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "setFragmentProgramParameters", VALUEFUNC(_wrap_Pass_setFragmentProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getFragmentProgramName", VALUEFUNC(_wrap_Pass_getFragmentProgramName), -1);
  rb_define_method(SwigClassPass.klass, "getFragmentProgramParameters", VALUEFUNC(_wrap_Pass_getFragmentProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getFragmentProgram", VALUEFUNC(_wrap_Pass_getFragmentProgram), -1);
  rb_define_method(SwigClassPass.klass, "setGeometryProgram", VALUEFUNC(_wrap_Pass_setGeometryProgram), -1);
  rb_define_method(SwigClassPass.klass, "setGeometryProgramParameters", VALUEFUNC(_wrap_Pass_setGeometryProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getGeometryProgramName", VALUEFUNC(_wrap_Pass_getGeometryProgramName), -1);
  rb_define_method(SwigClassPass.klass, "getGeometryProgramParameters", VALUEFUNC(_wrap_Pass_getGeometryProgramParameters), -1);
  rb_define_method(SwigClassPass.klass, "getGeometryProgram", VALUEFUNC(_wrap_Pass_getGeometryProgram), -1);
  rb_define_method(SwigClassPass.klass, "_split", VALUEFUNC(_wrap_Pass__split), -1);
  rb_define_method(SwigClassPass.klass, "_notifyIndex", VALUEFUNC(_wrap_Pass__notifyIndex), -1);
  rb_define_method(SwigClassPass.klass, "_prepare", VALUEFUNC(_wrap_Pass__prepare), -1);
  rb_define_method(SwigClassPass.klass, "_unprepare", VALUEFUNC(_wrap_Pass__unprepare), -1);
  rb_define_method(SwigClassPass.klass, "_load", VALUEFUNC(_wrap_Pass__load), -1);
  rb_define_method(SwigClassPass.klass, "_unload", VALUEFUNC(_wrap_Pass__unload), -1);
  rb_define_method(SwigClassPass.klass, "isLoaded", VALUEFUNC(_wrap_Pass_isLoaded), -1);
  rb_define_method(SwigClassPass.klass, "getHash", VALUEFUNC(_wrap_Pass_getHash), -1);
  rb_define_method(SwigClassPass.klass, "_dirtyHash", VALUEFUNC(_wrap_Pass__dirtyHash), -1);
  rb_define_method(SwigClassPass.klass, "_recalculateHash", VALUEFUNC(_wrap_Pass__recalculateHash), -1);
  rb_define_method(SwigClassPass.klass, "_notifyNeedsRecompile", VALUEFUNC(_wrap_Pass__notifyNeedsRecompile), -1);
  rb_define_method(SwigClassPass.klass, "_updateAutoParams", VALUEFUNC(_wrap_Pass__updateAutoParams), -1);
  rb_define_method(SwigClassPass.klass, "_getTextureUnitWithContentTypeIndex", VALUEFUNC(_wrap_Pass__getTextureUnitWithContentTypeIndex), -1);
  rb_define_method(SwigClassPass.klass, "setTextureFiltering", VALUEFUNC(_wrap_Pass_setTextureFiltering), -1);
  rb_define_method(SwigClassPass.klass, "setTextureAnisotropy", VALUEFUNC(_wrap_Pass_setTextureAnisotropy), -1);
  rb_define_method(SwigClassPass.klass, "setNormaliseNormals", VALUEFUNC(_wrap_Pass_setNormaliseNormals), -1);
  rb_define_method(SwigClassPass.klass, "getNormaliseNormals", VALUEFUNC(_wrap_Pass_getNormaliseNormals), -1);
  rb_define_singleton_method(SwigClassPass.klass, "getDirtyHashList", VALUEFUNC(_wrap_Pass_getDirtyHashList), -1);
  rb_define_singleton_method(SwigClassPass.klass, "getPassGraveyard", VALUEFUNC(_wrap_Pass_getPassGraveyard), -1);
  rb_define_singleton_method(SwigClassPass.klass, "clearDirtyHashList", VALUEFUNC(_wrap_Pass_clearDirtyHashList), -1);
  rb_define_singleton_method(SwigClassPass.klass, "processPendingPassUpdates", VALUEFUNC(_wrap_Pass_processPendingPassUpdates), -1);
  rb_define_method(SwigClassPass.klass, "queueForDeletion", VALUEFUNC(_wrap_Pass_queueForDeletion), -1);
  rb_define_method(SwigClassPass.klass, "isAmbientOnly", VALUEFUNC(_wrap_Pass_isAmbientOnly), -1);
  rb_define_method(SwigClassPass.klass, "setPassIterationCount", VALUEFUNC(_wrap_Pass_setPassIterationCount), -1);
  rb_define_method(SwigClassPass.klass, "getPassIterationCount", VALUEFUNC(_wrap_Pass_getPassIterationCount), -1);
  rb_define_method(SwigClassPass.klass, "applyTextureAliases", VALUEFUNC(_wrap_Pass_applyTextureAliases), -1);
  rb_define_method(SwigClassPass.klass, "setLightScissoringEnabled", VALUEFUNC(_wrap_Pass_setLightScissoringEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getLightScissoringEnabled", VALUEFUNC(_wrap_Pass_getLightScissoringEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setLightClipPlanesEnabled", VALUEFUNC(_wrap_Pass_setLightClipPlanesEnabled), -1);
  rb_define_method(SwigClassPass.klass, "getLightClipPlanesEnabled", VALUEFUNC(_wrap_Pass_getLightClipPlanesEnabled), -1);
  rb_define_method(SwigClassPass.klass, "setIlluminationStage", VALUEFUNC(_wrap_Pass_setIlluminationStage), -1);
  rb_define_method(SwigClassPass.klass, "getIlluminationStage", VALUEFUNC(_wrap_Pass_getIlluminationStage), -1);
  rb_define_const(SwigClassPass.klass, "MIN_TEXTURE_CHANGE", SWIG_From_int(static_cast< int >(Ogre::Pass::MIN_TEXTURE_CHANGE)));
  rb_define_const(SwigClassPass.klass, "MIN_GPU_PROGRAM_CHANGE", SWIG_From_int(static_cast< int >(Ogre::Pass::MIN_GPU_PROGRAM_CHANGE)));
  rb_define_singleton_method(SwigClassPass.klass, "setHashFunction", VALUEFUNC(_wrap_Pass_setHashFunction), -1);
  rb_define_singleton_method(SwigClassPass.klass, "getHashFunction", VALUEFUNC(_wrap_Pass_getHashFunction), -1);
  rb_define_singleton_method(SwigClassPass.klass, "getBuiltinHashFunction", VALUEFUNC(_wrap_Pass_getBuiltinHashFunction), -1);
  rb_define_method(SwigClassPass.klass, "getUserObjectBindings", VALUEFUNC(_wrap_Pass_getUserObjectBindings), -1);
  SwigClassPass.mark = 0;
  SwigClassPass.destroy = (void (*)(void *)) free_Ogre_Pass;
  SwigClassPass.trackObjects = 0;
  
  SwigClassIlluminationPass.klass = rb_define_class_under(mOgre, "IlluminationPass", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__IlluminationPass, (void *) &SwigClassIlluminationPass);
  rb_define_alloc_func(SwigClassIlluminationPass.klass, _wrap_IlluminationPass_allocate);
  rb_define_method(SwigClassIlluminationPass.klass, "initialize", VALUEFUNC(_wrap_new_IlluminationPass), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "stage=", VALUEFUNC(_wrap_IlluminationPass_stage_set), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "stage", VALUEFUNC(_wrap_IlluminationPass_stage_get), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "pass=", VALUEFUNC(_wrap_IlluminationPass_pass_set), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "pass", VALUEFUNC(_wrap_IlluminationPass_pass_get), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "destroyOnShutdown=", VALUEFUNC(_wrap_IlluminationPass_destroyOnShutdown_set), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "destroyOnShutdown", VALUEFUNC(_wrap_IlluminationPass_destroyOnShutdown_get), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "originalPass=", VALUEFUNC(_wrap_IlluminationPass_originalPass_set), -1);
  rb_define_method(SwigClassIlluminationPass.klass, "originalPass", VALUEFUNC(_wrap_IlluminationPass_originalPass_get), -1);
  SwigClassIlluminationPass.mark = 0;
  SwigClassIlluminationPass.destroy = (void (*)(void *)) free_Ogre_IlluminationPass;
  SwigClassIlluminationPass.trackObjects = 0;
  
  SwigClassPixelCountLodStrategy.klass = rb_define_class_under(mOgre, "PixelCountLodStrategy", ((swig_class *) SWIGTYPE_p_Ogre__LodStrategy->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PixelCountLodStrategy, (void *) &SwigClassPixelCountLodStrategy);
  rb_define_alloc_func(SwigClassPixelCountLodStrategy.klass, _wrap_PixelCountLodStrategy_allocate);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "initialize", VALUEFUNC(_wrap_new_PixelCountLodStrategy), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "getBaseValue", VALUEFUNC(_wrap_PixelCountLodStrategy_getBaseValue), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "transformBias", VALUEFUNC(_wrap_PixelCountLodStrategy_transformBias), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "getIndex", VALUEFUNC(_wrap_PixelCountLodStrategy_getIndex), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "sort", VALUEFUNC(_wrap_PixelCountLodStrategy_sort), -1);
  rb_define_method(SwigClassPixelCountLodStrategy.klass, "isSorted", VALUEFUNC(_wrap_PixelCountLodStrategy_isSorted), -1);
  rb_define_singleton_method(SwigClassPixelCountLodStrategy.klass, "getSingleton", VALUEFUNC(_wrap_PixelCountLodStrategy_getSingleton), -1);
  rb_define_singleton_method(SwigClassPixelCountLodStrategy.klass, "getSingletonPtr", VALUEFUNC(_wrap_PixelCountLodStrategy_getSingletonPtr), -1);
  SwigClassPixelCountLodStrategy.mark = 0;
  SwigClassPixelCountLodStrategy.destroy = (void (*)(void *)) free_Ogre_PixelCountLodStrategy;
  SwigClassPixelCountLodStrategy.trackObjects = 0;
  rb_define_const(mOgre, "OGRE_CPU_UNKNOWN", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_CPU_X86", SWIG_From_int(static_cast< int >(1)));
  rb_define_const(mOgre, "OGRE_CPU_PPC", SWIG_From_int(static_cast< int >(2)));
  rb_define_const(mOgre, "OGRE_CPU_ARM", SWIG_From_int(static_cast< int >(3)));
  rb_define_const(mOgre, "OGRE_CPU", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "OGRE_SIMD_ALIGNMENT", SWIG_From_int(static_cast< int >(16)));
  rb_define_const(mOgre, "__OGRE_HAVE_SSE", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "__OGRE_HAVE_VFP", SWIG_From_int(static_cast< int >(0)));
  rb_define_const(mOgre, "__OGRE_HAVE_NEON", SWIG_From_int(static_cast< int >(0)));
  
  SwigClassPlatformInformation.klass = rb_define_class_under(mOgre, "PlatformInformation", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PlatformInformation, (void *) &SwigClassPlatformInformation);
  rb_define_alloc_func(SwigClassPlatformInformation.klass, _wrap_PlatformInformation_allocate);
  rb_define_method(SwigClassPlatformInformation.klass, "initialize", VALUEFUNC(_wrap_new_PlatformInformation), -1);
  rb_define_const(SwigClassPlatformInformation.klass, "CPU_FEATURE_NONE", SWIG_From_int(static_cast< int >(Ogre::PlatformInformation::CPU_FEATURE_NONE)));
  rb_define_singleton_method(SwigClassPlatformInformation.klass, "getCpuIdentifier", VALUEFUNC(_wrap_PlatformInformation_getCpuIdentifier), -1);
  rb_define_singleton_method(SwigClassPlatformInformation.klass, "getCpuFeatures", VALUEFUNC(_wrap_PlatformInformation_getCpuFeatures), -1);
  rb_define_singleton_method(SwigClassPlatformInformation.klass, "hasCpuFeature", VALUEFUNC(_wrap_PlatformInformation_hasCpuFeature), -1);
  rb_define_singleton_method(SwigClassPlatformInformation.klass, "log", VALUEFUNC(_wrap_PlatformInformation_log), -1);
  SwigClassPlatformInformation.mark = 0;
  SwigClassPlatformInformation.destroy = (void (*)(void *)) free_Ogre_PlatformInformation;
  SwigClassPlatformInformation.trackObjects = 0;
  
  SwigClassPlugin.klass = rb_define_class_under(mOgre, "Plugin", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Plugin, (void *) &SwigClassPlugin);
  rb_undef_alloc_func(SwigClassPlugin.klass);
  rb_define_method(SwigClassPlugin.klass, "getName", VALUEFUNC(_wrap_Plugin_getName), -1);
  rb_define_method(SwigClassPlugin.klass, "install", VALUEFUNC(_wrap_Plugin_install), -1);
  rb_define_method(SwigClassPlugin.klass, "initialise", VALUEFUNC(_wrap_Plugin_initialise), -1);
  rb_define_method(SwigClassPlugin.klass, "shutdown", VALUEFUNC(_wrap_Plugin_shutdown), -1);
  rb_define_method(SwigClassPlugin.klass, "uninstall", VALUEFUNC(_wrap_Plugin_uninstall), -1);
  SwigClassPlugin.mark = 0;
  SwigClassPlugin.destroy = (void (*)(void *)) free_Ogre_Plugin;
  SwigClassPlugin.trackObjects = 0;
  
  SwigClassPrefabFactory.klass = rb_define_class_under(mOgre, "PrefabFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PrefabFactory, (void *) &SwigClassPrefabFactory);
  rb_define_alloc_func(SwigClassPrefabFactory.klass, _wrap_PrefabFactory_allocate);
  rb_define_method(SwigClassPrefabFactory.klass, "initialize", VALUEFUNC(_wrap_new_PrefabFactory), -1);
  rb_define_singleton_method(SwigClassPrefabFactory.klass, "createPrefab", VALUEFUNC(_wrap_PrefabFactory_createPrefab), -1);
  SwigClassPrefabFactory.mark = 0;
  SwigClassPrefabFactory.destroy = (void (*)(void *)) free_Ogre_PrefabFactory;
  SwigClassPrefabFactory.trackObjects = 0;
  rb_define_const(mOgre, "OGREPROF_USER_DEFAULT", SWIG_From_int(static_cast< int >(Ogre::OGREPROF_USER_DEFAULT)));
  rb_define_const(mOgre, "OGREPROF_ALL", SWIG_From_int(static_cast< int >(Ogre::OGREPROF_ALL)));
  rb_define_const(mOgre, "OGREPROF_GENERAL", SWIG_From_int(static_cast< int >(Ogre::OGREPROF_GENERAL)));
  rb_define_const(mOgre, "OGREPROF_CULLING", SWIG_From_int(static_cast< int >(Ogre::OGREPROF_CULLING)));
  rb_define_const(mOgre, "OGREPROF_RENDERING", SWIG_From_int(static_cast< int >(Ogre::OGREPROF_RENDERING)));
  
  SwigClassProfile.klass = rb_define_class_under(mOgre, "Profile", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Profile, (void *) &SwigClassProfile);
  rb_define_alloc_func(SwigClassProfile.klass, _wrap_Profile_allocate);
  rb_define_method(SwigClassProfile.klass, "initialize", VALUEFUNC(_wrap_new_Profile), -1);
  SwigClassProfile.mark = 0;
  SwigClassProfile.destroy = (void (*)(void *)) free_Ogre_Profile;
  SwigClassProfile.trackObjects = 0;
  
  SwigClassProfiler.klass = rb_define_class_under(mOgre, "Profiler", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Profiler, (void *) &SwigClassProfiler);
  rb_define_alloc_func(SwigClassProfiler.klass, _wrap_Profiler_allocate);
  rb_define_method(SwigClassProfiler.klass, "initialize", VALUEFUNC(_wrap_new_Profiler), -1);
  rb_define_method(SwigClassProfiler.klass, "setTimer", VALUEFUNC(_wrap_Profiler_setTimer), -1);
  rb_define_method(SwigClassProfiler.klass, "getTimer", VALUEFUNC(_wrap_Profiler_getTimer), -1);
  rb_define_method(SwigClassProfiler.klass, "beginProfile", VALUEFUNC(_wrap_Profiler_beginProfile), -1);
  rb_define_method(SwigClassProfiler.klass, "endProfile", VALUEFUNC(_wrap_Profiler_endProfile), -1);
  rb_define_method(SwigClassProfiler.klass, "setEnabled", VALUEFUNC(_wrap_Profiler_setEnabled), -1);
  rb_define_method(SwigClassProfiler.klass, "getEnabled", VALUEFUNC(_wrap_Profiler_getEnabled), -1);
  rb_define_method(SwigClassProfiler.klass, "enableProfile", VALUEFUNC(_wrap_Profiler_enableProfile), -1);
  rb_define_method(SwigClassProfiler.klass, "disableProfile", VALUEFUNC(_wrap_Profiler_disableProfile), -1);
  rb_define_method(SwigClassProfiler.klass, "setProfileGroupMask", VALUEFUNC(_wrap_Profiler_setProfileGroupMask), -1);
  rb_define_method(SwigClassProfiler.klass, "getProfileGroupMask", VALUEFUNC(_wrap_Profiler_getProfileGroupMask), -1);
  rb_define_method(SwigClassProfiler.klass, "watchForMax", VALUEFUNC(_wrap_Profiler_watchForMax), -1);
  rb_define_method(SwigClassProfiler.klass, "watchForMin", VALUEFUNC(_wrap_Profiler_watchForMin), -1);
  rb_define_method(SwigClassProfiler.klass, "watchForLimit", VALUEFUNC(_wrap_Profiler_watchForLimit), -1);
  rb_define_method(SwigClassProfiler.klass, "logResults", VALUEFUNC(_wrap_Profiler_logResults), -1);
  rb_define_method(SwigClassProfiler.klass, "reset", VALUEFUNC(_wrap_Profiler_reset), -1);
  rb_define_const(SwigClassProfiler.klass, "DISPLAY_PERCENTAGE", SWIG_From_int(static_cast< int >(Ogre::Profiler::DISPLAY_PERCENTAGE)));
  rb_define_const(SwigClassProfiler.klass, "DISPLAY_MILLISECONDS", SWIG_From_int(static_cast< int >(Ogre::Profiler::DISPLAY_MILLISECONDS)));
  rb_define_method(SwigClassProfiler.klass, "setDisplayMode", VALUEFUNC(_wrap_Profiler_setDisplayMode), -1);
  rb_define_method(SwigClassProfiler.klass, "getDisplayMode", VALUEFUNC(_wrap_Profiler_getDisplayMode), -1);
  rb_define_method(SwigClassProfiler.klass, "setUpdateDisplayFrequency", VALUEFUNC(_wrap_Profiler_setUpdateDisplayFrequency), -1);
  rb_define_method(SwigClassProfiler.klass, "getUpdateDisplayFrequency", VALUEFUNC(_wrap_Profiler_getUpdateDisplayFrequency), -1);
  rb_define_method(SwigClassProfiler.klass, "setOverlayDimensions", VALUEFUNC(_wrap_Profiler_setOverlayDimensions), -1);
  rb_define_method(SwigClassProfiler.klass, "setOverlayPosition", VALUEFUNC(_wrap_Profiler_setOverlayPosition), -1);
  rb_define_method(SwigClassProfiler.klass, "getOverlayWidth", VALUEFUNC(_wrap_Profiler_getOverlayWidth), -1);
  rb_define_method(SwigClassProfiler.klass, "getOverlayHeight", VALUEFUNC(_wrap_Profiler_getOverlayHeight), -1);
  rb_define_method(SwigClassProfiler.klass, "getOverlayLeft", VALUEFUNC(_wrap_Profiler_getOverlayLeft), -1);
  rb_define_method(SwigClassProfiler.klass, "getOverlayTop", VALUEFUNC(_wrap_Profiler_getOverlayTop), -1);
  rb_define_singleton_method(SwigClassProfiler.klass, "getSingleton", VALUEFUNC(_wrap_Profiler_getSingleton), -1);
  rb_define_singleton_method(SwigClassProfiler.klass, "getSingletonPtr", VALUEFUNC(_wrap_Profiler_getSingletonPtr), -1);
  SwigClassProfiler.mark = 0;
  SwigClassProfiler.destroy = (void (*)(void *)) free_Ogre_Profiler;
  SwigClassProfiler.trackObjects = 0;
  rb_define_module_function(mOgre, "disown_RenderObjectListener", VALUEFUNC(_wrap_disown_RenderObjectListener), -1);
  
  SwigClassRenderObjectListener.klass = rb_define_class_under(mOgre, "RenderObjectListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderObjectListener, (void *) &SwigClassRenderObjectListener);
  rb_define_alloc_func(SwigClassRenderObjectListener.klass, _wrap_RenderObjectListener_allocate);
  rb_define_method(SwigClassRenderObjectListener.klass, "initialize", VALUEFUNC(_wrap_new_RenderObjectListener), -1);
  rb_define_method(SwigClassRenderObjectListener.klass, "notifyRenderSingleObject", VALUEFUNC(_wrap_RenderObjectListener_notifyRenderSingleObject), -1);
  SwigClassRenderObjectListener.mark = 0;
  SwigClassRenderObjectListener.destroy = (void (*)(void *)) free_Ogre_RenderObjectListener;
  SwigClassRenderObjectListener.trackObjects = 0;
  
  SwigClassTechnique.klass = rb_define_class_under(mOgre, "Technique", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Technique, (void *) &SwigClassTechnique);
  rb_define_alloc_func(SwigClassTechnique.klass, _wrap_Technique_allocate);
  rb_define_method(SwigClassTechnique.klass, "initialize", VALUEFUNC(_wrap_new_Technique), -1);
  rb_define_const(SwigClassTechnique.klass, "INCLUDE", SWIG_From_int(static_cast< int >(Ogre::Technique::INCLUDE)));
  rb_define_const(SwigClassTechnique.klass, "EXCLUDE", SWIG_From_int(static_cast< int >(Ogre::Technique::EXCLUDE)));
  rb_define_method(SwigClassTechnique.klass, "isSupported", VALUEFUNC(_wrap_Technique_isSupported), -1);
  rb_define_method(SwigClassTechnique.klass, "_compile", VALUEFUNC(_wrap_Technique__compile), -1);
  rb_define_method(SwigClassTechnique.klass, "checkGPURules", VALUEFUNC(_wrap_Technique_checkGPURules), -1);
  rb_define_method(SwigClassTechnique.klass, "checkHardwareSupport", VALUEFUNC(_wrap_Technique_checkHardwareSupport), -1);
  rb_define_method(SwigClassTechnique.klass, "_compileIlluminationPasses", VALUEFUNC(_wrap_Technique__compileIlluminationPasses), -1);
  rb_define_method(SwigClassTechnique.klass, "createPass", VALUEFUNC(_wrap_Technique_createPass), -1);
  rb_define_method(SwigClassTechnique.klass, "getPass", VALUEFUNC(_wrap_Technique_getPass), -1);
  rb_define_method(SwigClassTechnique.klass, "getNumPasses", VALUEFUNC(_wrap_Technique_getNumPasses), -1);
  rb_define_method(SwigClassTechnique.klass, "removePass", VALUEFUNC(_wrap_Technique_removePass), -1);
  rb_define_method(SwigClassTechnique.klass, "removeAllPasses", VALUEFUNC(_wrap_Technique_removeAllPasses), -1);
  rb_define_method(SwigClassTechnique.klass, "movePass", VALUEFUNC(_wrap_Technique_movePass), -1);
  rb_define_method(SwigClassTechnique.klass, "getPassIterator", VALUEFUNC(_wrap_Technique_getPassIterator), -1);
  rb_define_method(SwigClassTechnique.klass, "getIlluminationPassIterator", VALUEFUNC(_wrap_Technique_getIlluminationPassIterator), -1);
  rb_define_method(SwigClassTechnique.klass, "getParent", VALUEFUNC(_wrap_Technique_getParent), -1);
  rb_define_method(SwigClassTechnique.klass, "getResourceGroup", VALUEFUNC(_wrap_Technique_getResourceGroup), -1);
  rb_define_method(SwigClassTechnique.klass, "isTransparent", VALUEFUNC(_wrap_Technique_isTransparent), -1);
  rb_define_method(SwigClassTechnique.klass, "isTransparentSortingEnabled", VALUEFUNC(_wrap_Technique_isTransparentSortingEnabled), -1);
  rb_define_method(SwigClassTechnique.klass, "isTransparentSortingForced", VALUEFUNC(_wrap_Technique_isTransparentSortingForced), -1);
  rb_define_method(SwigClassTechnique.klass, "_prepare", VALUEFUNC(_wrap_Technique__prepare), -1);
  rb_define_method(SwigClassTechnique.klass, "_unprepare", VALUEFUNC(_wrap_Technique__unprepare), -1);
  rb_define_method(SwigClassTechnique.klass, "_load", VALUEFUNC(_wrap_Technique__load), -1);
  rb_define_method(SwigClassTechnique.klass, "_unload", VALUEFUNC(_wrap_Technique__unload), -1);
  rb_define_method(SwigClassTechnique.klass, "isLoaded", VALUEFUNC(_wrap_Technique_isLoaded), -1);
  rb_define_method(SwigClassTechnique.klass, "_notifyNeedsRecompile", VALUEFUNC(_wrap_Technique__notifyNeedsRecompile), -1);
  rb_define_method(SwigClassTechnique.klass, "getShadowCasterMaterial", VALUEFUNC(_wrap_Technique_getShadowCasterMaterial), -1);
  rb_define_method(SwigClassTechnique.klass, "setShadowCasterMaterial", VALUEFUNC(_wrap_Technique_setShadowCasterMaterial), -1);
  rb_define_method(SwigClassTechnique.klass, "getShadowReceiverMaterial", VALUEFUNC(_wrap_Technique_getShadowReceiverMaterial), -1);
  rb_define_method(SwigClassTechnique.klass, "setShadowReceiverMaterial", VALUEFUNC(_wrap_Technique_setShadowReceiverMaterial), -1);
  rb_define_method(SwigClassTechnique.klass, "setPointSize", VALUEFUNC(_wrap_Technique_setPointSize), -1);
  rb_define_method(SwigClassTechnique.klass, "setAmbient", VALUEFUNC(_wrap_Technique_setAmbient), -1);
  rb_define_method(SwigClassTechnique.klass, "setDiffuse", VALUEFUNC(_wrap_Technique_setDiffuse), -1);
  rb_define_method(SwigClassTechnique.klass, "setSpecular", VALUEFUNC(_wrap_Technique_setSpecular), -1);
  rb_define_method(SwigClassTechnique.klass, "setShininess", VALUEFUNC(_wrap_Technique_setShininess), -1);
  rb_define_method(SwigClassTechnique.klass, "setSelfIllumination", VALUEFUNC(_wrap_Technique_setSelfIllumination), -1);
  rb_define_method(SwigClassTechnique.klass, "setDepthCheckEnabled", VALUEFUNC(_wrap_Technique_setDepthCheckEnabled), -1);
  rb_define_method(SwigClassTechnique.klass, "setDepthWriteEnabled", VALUEFUNC(_wrap_Technique_setDepthWriteEnabled), -1);
  rb_define_method(SwigClassTechnique.klass, "setDepthFunction", VALUEFUNC(_wrap_Technique_setDepthFunction), -1);
  rb_define_method(SwigClassTechnique.klass, "setColourWriteEnabled", VALUEFUNC(_wrap_Technique_setColourWriteEnabled), -1);
  rb_define_method(SwigClassTechnique.klass, "setCullingMode", VALUEFUNC(_wrap_Technique_setCullingMode), -1);
  rb_define_method(SwigClassTechnique.klass, "setManualCullingMode", VALUEFUNC(_wrap_Technique_setManualCullingMode), -1);
  rb_define_method(SwigClassTechnique.klass, "setLightingEnabled", VALUEFUNC(_wrap_Technique_setLightingEnabled), -1);
  rb_define_method(SwigClassTechnique.klass, "setShadingMode", VALUEFUNC(_wrap_Technique_setShadingMode), -1);
  rb_define_method(SwigClassTechnique.klass, "setFog", VALUEFUNC(_wrap_Technique_setFog), -1);
  rb_define_method(SwigClassTechnique.klass, "setDepthBias", VALUEFUNC(_wrap_Technique_setDepthBias), -1);
  rb_define_method(SwigClassTechnique.klass, "setTextureFiltering", VALUEFUNC(_wrap_Technique_setTextureFiltering), -1);
  rb_define_method(SwigClassTechnique.klass, "setTextureAnisotropy", VALUEFUNC(_wrap_Technique_setTextureAnisotropy), -1);
  rb_define_method(SwigClassTechnique.klass, "setSceneBlending", VALUEFUNC(_wrap_Technique_setSceneBlending), -1);
  rb_define_method(SwigClassTechnique.klass, "setSeparateSceneBlending", VALUEFUNC(_wrap_Technique_setSeparateSceneBlending), -1);
  rb_define_method(SwigClassTechnique.klass, "setLodIndex", VALUEFUNC(_wrap_Technique_setLodIndex), -1);
  rb_define_method(SwigClassTechnique.klass, "getLodIndex", VALUEFUNC(_wrap_Technique_getLodIndex), -1);
  rb_define_method(SwigClassTechnique.klass, "setSchemeName", VALUEFUNC(_wrap_Technique_setSchemeName), -1);
  rb_define_method(SwigClassTechnique.klass, "getSchemeName", VALUEFUNC(_wrap_Technique_getSchemeName), -1);
  rb_define_method(SwigClassTechnique.klass, "_getSchemeIndex", VALUEFUNC(_wrap_Technique__getSchemeIndex), -1);
  rb_define_method(SwigClassTechnique.klass, "isDepthWriteEnabled", VALUEFUNC(_wrap_Technique_isDepthWriteEnabled), -1);
  rb_define_method(SwigClassTechnique.klass, "isDepthCheckEnabled", VALUEFUNC(_wrap_Technique_isDepthCheckEnabled), -1);
  rb_define_method(SwigClassTechnique.klass, "hasColourWriteDisabled", VALUEFUNC(_wrap_Technique_hasColourWriteDisabled), -1);
  rb_define_method(SwigClassTechnique.klass, "setName", VALUEFUNC(_wrap_Technique_setName), -1);
  rb_define_method(SwigClassTechnique.klass, "getName", VALUEFUNC(_wrap_Technique_getName), -1);
  rb_define_method(SwigClassTechnique.klass, "applyTextureAliases", VALUEFUNC(_wrap_Technique_applyTextureAliases), -1);
  rb_define_method(SwigClassTechnique.klass, "addGPUVendorRule", VALUEFUNC(_wrap_Technique_addGPUVendorRule), -1);
  rb_define_method(SwigClassTechnique.klass, "removeGPUVendorRule", VALUEFUNC(_wrap_Technique_removeGPUVendorRule), -1);
  rb_define_method(SwigClassTechnique.klass, "getGPUVendorRuleIterator", VALUEFUNC(_wrap_Technique_getGPUVendorRuleIterator), -1);
  rb_define_method(SwigClassTechnique.klass, "addGPUDeviceNameRule", VALUEFUNC(_wrap_Technique_addGPUDeviceNameRule), -1);
  rb_define_method(SwigClassTechnique.klass, "removeGPUDeviceNameRule", VALUEFUNC(_wrap_Technique_removeGPUDeviceNameRule), -1);
  rb_define_method(SwigClassTechnique.klass, "getGPUDeviceNameRuleIterator", VALUEFUNC(_wrap_Technique_getGPUDeviceNameRuleIterator), -1);
  rb_define_method(SwigClassTechnique.klass, "getUserObjectBindings", VALUEFUNC(_wrap_Technique_getUserObjectBindings), -1);
  SwigClassTechnique.mark = 0;
  SwigClassTechnique.destroy = (void (*)(void *)) free_Ogre_Technique;
  SwigClassTechnique.trackObjects = 0;
  
  SwigClassRenderablePass.klass = rb_define_class_under(mOgre, "RenderablePass", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderablePass, (void *) &SwigClassRenderablePass);
  rb_define_alloc_func(SwigClassRenderablePass.klass, _wrap_RenderablePass_allocate);
  rb_define_method(SwigClassRenderablePass.klass, "initialize", VALUEFUNC(_wrap_new_RenderablePass), -1);
  rb_define_method(SwigClassRenderablePass.klass, "renderable=", VALUEFUNC(_wrap_RenderablePass_renderable_set), -1);
  rb_define_method(SwigClassRenderablePass.klass, "renderable", VALUEFUNC(_wrap_RenderablePass_renderable_get), -1);
  rb_define_method(SwigClassRenderablePass.klass, "pass=", VALUEFUNC(_wrap_RenderablePass_pass_set), -1);
  rb_define_method(SwigClassRenderablePass.klass, "pass", VALUEFUNC(_wrap_RenderablePass_pass_get), -1);
  SwigClassRenderablePass.mark = 0;
  SwigClassRenderablePass.destroy = (void (*)(void *)) free_Ogre_RenderablePass;
  SwigClassRenderablePass.trackObjects = 0;
  
  SwigClassQueuedRenderableVisitor.klass = rb_define_class_under(mOgre, "QueuedRenderableVisitor", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__QueuedRenderableVisitor, (void *) &SwigClassQueuedRenderableVisitor);
  rb_undef_alloc_func(SwigClassQueuedRenderableVisitor.klass);
  rb_define_method(SwigClassQueuedRenderableVisitor.klass, "visit", VALUEFUNC(_wrap_QueuedRenderableVisitor_visit), -1);
  SwigClassQueuedRenderableVisitor.mark = 0;
  SwigClassQueuedRenderableVisitor.destroy = (void (*)(void *)) free_Ogre_QueuedRenderableVisitor;
  SwigClassQueuedRenderableVisitor.trackObjects = 0;
  
  SwigClassQueuedRenderableCollection.klass = rb_define_class_under(mOgre, "QueuedRenderableCollection", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__QueuedRenderableCollection, (void *) &SwigClassQueuedRenderableCollection);
  rb_define_alloc_func(SwigClassQueuedRenderableCollection.klass, _wrap_QueuedRenderableCollection_allocate);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "initialize", VALUEFUNC(_wrap_new_QueuedRenderableCollection), -1);
  rb_define_const(SwigClassQueuedRenderableCollection.klass, "OM_PASS_GROUP", SWIG_From_int(static_cast< int >(Ogre::QueuedRenderableCollection::OM_PASS_GROUP)));
  rb_define_const(SwigClassQueuedRenderableCollection.klass, "OM_SORT_DESCENDING", SWIG_From_int(static_cast< int >(Ogre::QueuedRenderableCollection::OM_SORT_DESCENDING)));
  rb_define_const(SwigClassQueuedRenderableCollection.klass, "OM_SORT_ASCENDING", SWIG_From_int(static_cast< int >(Ogre::QueuedRenderableCollection::OM_SORT_ASCENDING)));
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "clear", VALUEFUNC(_wrap_QueuedRenderableCollection_clear), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "removePassGroup", VALUEFUNC(_wrap_QueuedRenderableCollection_removePassGroup), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "resetOrganisationModes", VALUEFUNC(_wrap_QueuedRenderableCollection_resetOrganisationModes), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "addOrganisationMode", VALUEFUNC(_wrap_QueuedRenderableCollection_addOrganisationMode), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "addRenderable", VALUEFUNC(_wrap_QueuedRenderableCollection_addRenderable), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "sort", VALUEFUNC(_wrap_QueuedRenderableCollection_sort), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "acceptVisitor", VALUEFUNC(_wrap_QueuedRenderableCollection_acceptVisitor), -1);
  rb_define_method(SwigClassQueuedRenderableCollection.klass, "merge", VALUEFUNC(_wrap_QueuedRenderableCollection_merge), -1);
  SwigClassQueuedRenderableCollection.mark = 0;
  SwigClassQueuedRenderableCollection.destroy = (void (*)(void *)) free_Ogre_QueuedRenderableCollection;
  SwigClassQueuedRenderableCollection.trackObjects = 0;
  
  SwigClassRenderPriorityGroup.klass = rb_define_class_under(mOgre, "RenderPriorityGroup", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderPriorityGroup, (void *) &SwigClassRenderPriorityGroup);
  rb_define_alloc_func(SwigClassRenderPriorityGroup.klass, _wrap_RenderPriorityGroup_allocate);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "initialize", VALUEFUNC(_wrap_new_RenderPriorityGroup), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "getSolidsBasic", VALUEFUNC(_wrap_RenderPriorityGroup_getSolidsBasic), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "getSolidsDiffuseSpecular", VALUEFUNC(_wrap_RenderPriorityGroup_getSolidsDiffuseSpecular), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "getSolidsDecal", VALUEFUNC(_wrap_RenderPriorityGroup_getSolidsDecal), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "getSolidsNoShadowReceive", VALUEFUNC(_wrap_RenderPriorityGroup_getSolidsNoShadowReceive), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "getTransparentsUnsorted", VALUEFUNC(_wrap_RenderPriorityGroup_getTransparentsUnsorted), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "getTransparents", VALUEFUNC(_wrap_RenderPriorityGroup_getTransparents), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "resetOrganisationModes", VALUEFUNC(_wrap_RenderPriorityGroup_resetOrganisationModes), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "addOrganisationMode", VALUEFUNC(_wrap_RenderPriorityGroup_addOrganisationMode), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "defaultOrganisationMode", VALUEFUNC(_wrap_RenderPriorityGroup_defaultOrganisationMode), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "addRenderable", VALUEFUNC(_wrap_RenderPriorityGroup_addRenderable), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "sort", VALUEFUNC(_wrap_RenderPriorityGroup_sort), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "clear", VALUEFUNC(_wrap_RenderPriorityGroup_clear), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "setSplitPassesByLightingType", VALUEFUNC(_wrap_RenderPriorityGroup_setSplitPassesByLightingType), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "setSplitNoShadowPasses", VALUEFUNC(_wrap_RenderPriorityGroup_setSplitNoShadowPasses), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "setShadowCastersCannotBeReceivers", VALUEFUNC(_wrap_RenderPriorityGroup_setShadowCastersCannotBeReceivers), -1);
  rb_define_method(SwigClassRenderPriorityGroup.klass, "merge", VALUEFUNC(_wrap_RenderPriorityGroup_merge), -1);
  SwigClassRenderPriorityGroup.mark = 0;
  SwigClassRenderPriorityGroup.destroy = (void (*)(void *)) free_Ogre_RenderPriorityGroup;
  SwigClassRenderPriorityGroup.trackObjects = 0;
  
  SwigClassRenderQueueGroup.klass = rb_define_class_under(mOgre, "RenderQueueGroup", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderQueueGroup, (void *) &SwigClassRenderQueueGroup);
  rb_define_alloc_func(SwigClassRenderQueueGroup.klass, _wrap_RenderQueueGroup_allocate);
  rb_define_method(SwigClassRenderQueueGroup.klass, "initialize", VALUEFUNC(_wrap_new_RenderQueueGroup), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "getIterator", VALUEFUNC(_wrap_RenderQueueGroup_getIterator), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "addRenderable", VALUEFUNC(_wrap_RenderQueueGroup_addRenderable), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "clear", VALUEFUNC(_wrap_RenderQueueGroup_clear), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "setShadowsEnabled", VALUEFUNC(_wrap_RenderQueueGroup_setShadowsEnabled), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "getShadowsEnabled", VALUEFUNC(_wrap_RenderQueueGroup_getShadowsEnabled), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "setSplitPassesByLightingType", VALUEFUNC(_wrap_RenderQueueGroup_setSplitPassesByLightingType), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "setSplitNoShadowPasses", VALUEFUNC(_wrap_RenderQueueGroup_setSplitNoShadowPasses), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "setShadowCastersCannotBeReceivers", VALUEFUNC(_wrap_RenderQueueGroup_setShadowCastersCannotBeReceivers), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "resetOrganisationModes", VALUEFUNC(_wrap_RenderQueueGroup_resetOrganisationModes), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "addOrganisationMode", VALUEFUNC(_wrap_RenderQueueGroup_addOrganisationMode), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "defaultOrganisationMode", VALUEFUNC(_wrap_RenderQueueGroup_defaultOrganisationMode), -1);
  rb_define_method(SwigClassRenderQueueGroup.klass, "merge", VALUEFUNC(_wrap_RenderQueueGroup_merge), -1);
  SwigClassRenderQueueGroup.mark = 0;
  SwigClassRenderQueueGroup.destroy = (void (*)(void *)) free_Ogre_RenderQueueGroup;
  SwigClassRenderQueueGroup.trackObjects = 0;
  
  SwigClassRenderQueueInvocation.klass = rb_define_class_under(mOgre, "RenderQueueInvocation", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderQueueInvocation, (void *) &SwigClassRenderQueueInvocation);
  rb_define_alloc_func(SwigClassRenderQueueInvocation.klass, _wrap_RenderQueueInvocation_allocate);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "initialize", VALUEFUNC(_wrap_new_RenderQueueInvocation), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "getRenderQueueGroupID", VALUEFUNC(_wrap_RenderQueueInvocation_getRenderQueueGroupID), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "getInvocationName", VALUEFUNC(_wrap_RenderQueueInvocation_getInvocationName), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "setSolidsOrganisation", VALUEFUNC(_wrap_RenderQueueInvocation_setSolidsOrganisation), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "getSolidsOrganisation", VALUEFUNC(_wrap_RenderQueueInvocation_getSolidsOrganisation), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "setSuppressShadows", VALUEFUNC(_wrap_RenderQueueInvocation_setSuppressShadows), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "getSuppressShadows", VALUEFUNC(_wrap_RenderQueueInvocation_getSuppressShadows), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "setSuppressRenderStateChanges", VALUEFUNC(_wrap_RenderQueueInvocation_setSuppressRenderStateChanges), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "getSuppressRenderStateChanges", VALUEFUNC(_wrap_RenderQueueInvocation_getSuppressRenderStateChanges), -1);
  rb_define_method(SwigClassRenderQueueInvocation.klass, "invoke", VALUEFUNC(_wrap_RenderQueueInvocation_invoke), -1);
  rb_define_singleton_method(SwigClassRenderQueueInvocation.klass, "RENDER_QUEUE_INVOCATION_SHADOWS", VALUEFUNC(_wrap_RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS_get), 0);
  rb_define_singleton_method(SwigClassRenderQueueInvocation.klass, "RENDER_QUEUE_INVOCATION_SHADOWS=", VALUEFUNC(_wrap_RenderQueueInvocation_RENDER_QUEUE_INVOCATION_SHADOWS_set), 1);
  SwigClassRenderQueueInvocation.mark = 0;
  SwigClassRenderQueueInvocation.destroy = (void (*)(void *)) free_Ogre_RenderQueueInvocation;
  SwigClassRenderQueueInvocation.trackObjects = 0;
  
  SwigClassRenderQueueInvocationSequence.klass = rb_define_class_under(mOgre, "RenderQueueInvocationSequence", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderQueueInvocationSequence, (void *) &SwigClassRenderQueueInvocationSequence);
  rb_define_alloc_func(SwigClassRenderQueueInvocationSequence.klass, _wrap_RenderQueueInvocationSequence_allocate);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "initialize", VALUEFUNC(_wrap_new_RenderQueueInvocationSequence), -1);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "getName", VALUEFUNC(_wrap_RenderQueueInvocationSequence_getName), -1);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "add", VALUEFUNC(_wrap_RenderQueueInvocationSequence_add), -1);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "size", VALUEFUNC(_wrap_RenderQueueInvocationSequence_size), -1);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "clear", VALUEFUNC(_wrap_RenderQueueInvocationSequence_clear), -1);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "get", VALUEFUNC(_wrap_RenderQueueInvocationSequence_get), -1);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "remove", VALUEFUNC(_wrap_RenderQueueInvocationSequence_remove), -1);
  rb_define_method(SwigClassRenderQueueInvocationSequence.klass, "iterator", VALUEFUNC(_wrap_RenderQueueInvocationSequence_iterator), -1);
  SwigClassRenderQueueInvocationSequence.mark = 0;
  SwigClassRenderQueueInvocationSequence.destroy = (void (*)(void *)) free_Ogre_RenderQueueInvocationSequence;
  SwigClassRenderQueueInvocationSequence.trackObjects = 0;
  
  SwigClassRenderSystemCapabilitiesManager.klass = rb_define_class_under(mOgre, "RenderSystemCapabilitiesManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderSystemCapabilitiesManager, (void *) &SwigClassRenderSystemCapabilitiesManager);
  rb_define_alloc_func(SwigClassRenderSystemCapabilitiesManager.klass, _wrap_RenderSystemCapabilitiesManager_allocate);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "initialize", VALUEFUNC(_wrap_new_RenderSystemCapabilitiesManager), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "parseCapabilitiesFromArchive", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_parseCapabilitiesFromArchive), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "loadParsedCapabilities", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_loadParsedCapabilities), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "getCapabilities", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_getCapabilities), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesManager.klass, "_addRenderSystemCapabilities", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager__addRenderSystemCapabilities), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilitiesManager.klass, "getSingleton", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassRenderSystemCapabilitiesManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_RenderSystemCapabilitiesManager_getSingletonPtr), -1);
  SwigClassRenderSystemCapabilitiesManager.mark = 0;
  SwigClassRenderSystemCapabilitiesManager.destroy = (void (*)(void *)) free_Ogre_RenderSystemCapabilitiesManager;
  SwigClassRenderSystemCapabilitiesManager.trackObjects = 0;
  
  SwigClassRenderSystemCapabilitiesSerializer.klass = rb_define_class_under(mOgre, "RenderSystemCapabilitiesSerializer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderSystemCapabilitiesSerializer, (void *) &SwigClassRenderSystemCapabilitiesSerializer);
  rb_define_alloc_func(SwigClassRenderSystemCapabilitiesSerializer.klass, _wrap_RenderSystemCapabilitiesSerializer_allocate);
  rb_define_method(SwigClassRenderSystemCapabilitiesSerializer.klass, "initialize", VALUEFUNC(_wrap_new_RenderSystemCapabilitiesSerializer), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesSerializer.klass, "writeScript", VALUEFUNC(_wrap_RenderSystemCapabilitiesSerializer_writeScript), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesSerializer.klass, "writeString", VALUEFUNC(_wrap_RenderSystemCapabilitiesSerializer_writeString), -1);
  rb_define_method(SwigClassRenderSystemCapabilitiesSerializer.klass, "parseScript", VALUEFUNC(_wrap_RenderSystemCapabilitiesSerializer_parseScript), -1);
  SwigClassRenderSystemCapabilitiesSerializer.mark = 0;
  SwigClassRenderSystemCapabilitiesSerializer.destroy = (void (*)(void *)) free_Ogre_RenderSystemCapabilitiesSerializer;
  SwigClassRenderSystemCapabilitiesSerializer.trackObjects = 0;
  
  SwigClassRenderWindow.klass = rb_define_class_under(mOgre, "RenderWindow", ((swig_class *) SWIGTYPE_p_Ogre__RenderTarget->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RenderWindow, (void *) &SwigClassRenderWindow);
  rb_undef_alloc_func(SwigClassRenderWindow.klass);
  rb_define_method(SwigClassRenderWindow.klass, "create", VALUEFUNC(_wrap_RenderWindow_create), -1);
  rb_define_method(SwigClassRenderWindow.klass, "setFullscreen", VALUEFUNC(_wrap_RenderWindow_setFullscreen), -1);
  rb_define_method(SwigClassRenderWindow.klass, "destroy", VALUEFUNC(_wrap_RenderWindow_destroy), -1);
  rb_define_method(SwigClassRenderWindow.klass, "resize", VALUEFUNC(_wrap_RenderWindow_resize), -1);
  rb_define_method(SwigClassRenderWindow.klass, "windowMovedOrResized", VALUEFUNC(_wrap_RenderWindow_windowMovedOrResized), -1);
  rb_define_method(SwigClassRenderWindow.klass, "reposition", VALUEFUNC(_wrap_RenderWindow_reposition), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isVisible", VALUEFUNC(_wrap_RenderWindow_isVisible), -1);
  rb_define_method(SwigClassRenderWindow.klass, "setVisible", VALUEFUNC(_wrap_RenderWindow_setVisible), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isHidden", VALUEFUNC(_wrap_RenderWindow_isHidden), -1);
  rb_define_method(SwigClassRenderWindow.klass, "setHidden", VALUEFUNC(_wrap_RenderWindow_setHidden), -1);
  rb_define_method(SwigClassRenderWindow.klass, "setVSyncEnabled", VALUEFUNC(_wrap_RenderWindow_setVSyncEnabled), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isVSyncEnabled", VALUEFUNC(_wrap_RenderWindow_isVSyncEnabled), -1);
  rb_define_method(SwigClassRenderWindow.klass, "setVSyncInterval", VALUEFUNC(_wrap_RenderWindow_setVSyncInterval), -1);
  rb_define_method(SwigClassRenderWindow.klass, "getVSyncInterval", VALUEFUNC(_wrap_RenderWindow_getVSyncInterval), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isActive", VALUEFUNC(_wrap_RenderWindow_isActive), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isClosed", VALUEFUNC(_wrap_RenderWindow_isClosed), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isPrimary", VALUEFUNC(_wrap_RenderWindow_isPrimary), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isFullScreen", VALUEFUNC(_wrap_RenderWindow_isFullScreen), -1);
  rb_define_method(SwigClassRenderWindow.klass, "getMetrics", VALUEFUNC(_wrap_RenderWindow_getMetrics), -1);
  rb_define_method(SwigClassRenderWindow.klass, "suggestPixelFormat", VALUEFUNC(_wrap_RenderWindow_suggestPixelFormat), -1);
  rb_define_method(SwigClassRenderWindow.klass, "isDeactivatedOnFocusChange", VALUEFUNC(_wrap_RenderWindow_isDeactivatedOnFocusChange), -1);
  rb_define_method(SwigClassRenderWindow.klass, "setDeactivateOnFocusChange", VALUEFUNC(_wrap_RenderWindow_setDeactivateOnFocusChange), -1);
  SwigClassRenderWindow.mark = 0;
  SwigClassRenderWindow.destroy = (void (*)(void *)) free_Ogre_RenderWindow;
  SwigClassRenderWindow.trackObjects = 0;
  
  SwigClassWorkQueue.klass = rb_define_class_under(mOgre, "WorkQueue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__WorkQueue, (void *) &SwigClassWorkQueue);
  rb_undef_alloc_func(SwigClassWorkQueue.klass);
  rb_define_method(SwigClassWorkQueue.klass, "startup", VALUEFUNC(_wrap_WorkQueue_startup), -1);
  rb_define_method(SwigClassWorkQueue.klass, "addRequestHandler", VALUEFUNC(_wrap_WorkQueue_addRequestHandler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "removeRequestHandler", VALUEFUNC(_wrap_WorkQueue_removeRequestHandler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "addResponseHandler", VALUEFUNC(_wrap_WorkQueue_addResponseHandler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "removeResponseHandler", VALUEFUNC(_wrap_WorkQueue_removeResponseHandler), -1);
  rb_define_method(SwigClassWorkQueue.klass, "addRequest", VALUEFUNC(_wrap_WorkQueue_addRequest), -1);
  rb_define_method(SwigClassWorkQueue.klass, "abortRequest", VALUEFUNC(_wrap_WorkQueue_abortRequest), -1);
  rb_define_method(SwigClassWorkQueue.klass, "abortRequestsByChannel", VALUEFUNC(_wrap_WorkQueue_abortRequestsByChannel), -1);
  rb_define_method(SwigClassWorkQueue.klass, "abortAllRequests", VALUEFUNC(_wrap_WorkQueue_abortAllRequests), -1);
  rb_define_method(SwigClassWorkQueue.klass, "setPaused", VALUEFUNC(_wrap_WorkQueue_setPaused), -1);
  rb_define_method(SwigClassWorkQueue.klass, "isPaused", VALUEFUNC(_wrap_WorkQueue_isPaused), -1);
  rb_define_method(SwigClassWorkQueue.klass, "setRequestsAccepted", VALUEFUNC(_wrap_WorkQueue_setRequestsAccepted), -1);
  rb_define_method(SwigClassWorkQueue.klass, "getRequestsAccepted", VALUEFUNC(_wrap_WorkQueue_getRequestsAccepted), -1);
  rb_define_method(SwigClassWorkQueue.klass, "processResponses", VALUEFUNC(_wrap_WorkQueue_processResponses), -1);
  rb_define_method(SwigClassWorkQueue.klass, "getResponseProcessingTimeLimit", VALUEFUNC(_wrap_WorkQueue_getResponseProcessingTimeLimit), -1);
  rb_define_method(SwigClassWorkQueue.klass, "setResponseProcessingTimeLimit", VALUEFUNC(_wrap_WorkQueue_setResponseProcessingTimeLimit), -1);
  rb_define_method(SwigClassWorkQueue.klass, "shutdown", VALUEFUNC(_wrap_WorkQueue_shutdown), -1);
  rb_define_method(SwigClassWorkQueue.klass, "getChannel", VALUEFUNC(_wrap_WorkQueue_getChannel), -1);
  SwigClassWorkQueue.mark = 0;
  SwigClassWorkQueue.destroy = (void (*)(void *)) free_Ogre_WorkQueue;
  SwigClassWorkQueue.trackObjects = 0;
  
  SwigClassDefaultWorkQueueBase.klass = rb_define_class_under(mOgre, "DefaultWorkQueueBase", ((swig_class *) SWIGTYPE_p_Ogre__WorkQueue->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultWorkQueueBase, (void *) &SwigClassDefaultWorkQueueBase);
  rb_undef_alloc_func(SwigClassDefaultWorkQueueBase.klass);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "getName", VALUEFUNC(_wrap_DefaultWorkQueueBase_getName), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "getWorkerThreadCount", VALUEFUNC(_wrap_DefaultWorkQueueBase_getWorkerThreadCount), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "setWorkerThreadCount", VALUEFUNC(_wrap_DefaultWorkQueueBase_setWorkerThreadCount), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "getWorkersCanAccessRenderSystem", VALUEFUNC(_wrap_DefaultWorkQueueBase_getWorkersCanAccessRenderSystem), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "setWorkersCanAccessRenderSystem", VALUEFUNC(_wrap_DefaultWorkQueueBase_setWorkersCanAccessRenderSystem), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "_processNextRequest", VALUEFUNC(_wrap_DefaultWorkQueueBase__processNextRequest), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "_threadMain", VALUEFUNC(_wrap_DefaultWorkQueueBase__threadMain), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "isShuttingDown", VALUEFUNC(_wrap_DefaultWorkQueueBase_isShuttingDown), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "addRequestHandler", VALUEFUNC(_wrap_DefaultWorkQueueBase_addRequestHandler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "removeRequestHandler", VALUEFUNC(_wrap_DefaultWorkQueueBase_removeRequestHandler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "addResponseHandler", VALUEFUNC(_wrap_DefaultWorkQueueBase_addResponseHandler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "removeResponseHandler", VALUEFUNC(_wrap_DefaultWorkQueueBase_removeResponseHandler), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "addRequest", VALUEFUNC(_wrap_DefaultWorkQueueBase_addRequest), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "abortRequest", VALUEFUNC(_wrap_DefaultWorkQueueBase_abortRequest), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "abortRequestsByChannel", VALUEFUNC(_wrap_DefaultWorkQueueBase_abortRequestsByChannel), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "abortAllRequests", VALUEFUNC(_wrap_DefaultWorkQueueBase_abortAllRequests), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "setPaused", VALUEFUNC(_wrap_DefaultWorkQueueBase_setPaused), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "isPaused", VALUEFUNC(_wrap_DefaultWorkQueueBase_isPaused), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "setRequestsAccepted", VALUEFUNC(_wrap_DefaultWorkQueueBase_setRequestsAccepted), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "getRequestsAccepted", VALUEFUNC(_wrap_DefaultWorkQueueBase_getRequestsAccepted), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "processResponses", VALUEFUNC(_wrap_DefaultWorkQueueBase_processResponses), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "getResponseProcessingTimeLimit", VALUEFUNC(_wrap_DefaultWorkQueueBase_getResponseProcessingTimeLimit), -1);
  rb_define_method(SwigClassDefaultWorkQueueBase.klass, "setResponseProcessingTimeLimit", VALUEFUNC(_wrap_DefaultWorkQueueBase_setResponseProcessingTimeLimit), -1);
  SwigClassDefaultWorkQueueBase.mark = 0;
  SwigClassDefaultWorkQueueBase.destroy = (void (*)(void *)) free_Ogre_DefaultWorkQueueBase;
  SwigClassDefaultWorkQueueBase.trackObjects = 0;
  
  SwigClassBackgroundProcessResult.klass = rb_define_class_under(mOgre, "BackgroundProcessResult", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BackgroundProcessResult, (void *) &SwigClassBackgroundProcessResult);
  rb_define_alloc_func(SwigClassBackgroundProcessResult.klass, _wrap_BackgroundProcessResult_allocate);
  rb_define_method(SwigClassBackgroundProcessResult.klass, "initialize", VALUEFUNC(_wrap_new_BackgroundProcessResult), -1);
  rb_define_method(SwigClassBackgroundProcessResult.klass, "error=", VALUEFUNC(_wrap_BackgroundProcessResult_error_set), -1);
  rb_define_method(SwigClassBackgroundProcessResult.klass, "error", VALUEFUNC(_wrap_BackgroundProcessResult_error_get), -1);
  rb_define_method(SwigClassBackgroundProcessResult.klass, "message=", VALUEFUNC(_wrap_BackgroundProcessResult_message_set), -1);
  rb_define_method(SwigClassBackgroundProcessResult.klass, "message", VALUEFUNC(_wrap_BackgroundProcessResult_message_get), -1);
  SwigClassBackgroundProcessResult.mark = 0;
  SwigClassBackgroundProcessResult.destroy = (void (*)(void *)) free_Ogre_BackgroundProcessResult;
  SwigClassBackgroundProcessResult.trackObjects = 0;
  
  SwigClassResourceBackgroundQueue.klass = rb_define_class_under(mOgre, "ResourceBackgroundQueue", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ResourceBackgroundQueue, (void *) &SwigClassResourceBackgroundQueue);
  rb_define_alloc_func(SwigClassResourceBackgroundQueue.klass, _wrap_ResourceBackgroundQueue_allocate);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "initialize", VALUEFUNC(_wrap_new_ResourceBackgroundQueue), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "initialise", VALUEFUNC(_wrap_ResourceBackgroundQueue_initialise), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "shutdown", VALUEFUNC(_wrap_ResourceBackgroundQueue_shutdown), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "initialiseResourceGroup", VALUEFUNC(_wrap_ResourceBackgroundQueue_initialiseResourceGroup), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "initialiseAllResourceGroups", VALUEFUNC(_wrap_ResourceBackgroundQueue_initialiseAllResourceGroups), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "prepareResourceGroup", VALUEFUNC(_wrap_ResourceBackgroundQueue_prepareResourceGroup), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "loadResourceGroup", VALUEFUNC(_wrap_ResourceBackgroundQueue_loadResourceGroup), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "unload", VALUEFUNC(_wrap_ResourceBackgroundQueue_unload), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "unloadResourceGroup", VALUEFUNC(_wrap_ResourceBackgroundQueue_unloadResourceGroup), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "prepare", VALUEFUNC(_wrap_ResourceBackgroundQueue_prepare), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "load", VALUEFUNC(_wrap_ResourceBackgroundQueue_load), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "isProcessComplete", VALUEFUNC(_wrap_ResourceBackgroundQueue_isProcessComplete), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "abortRequest", VALUEFUNC(_wrap_ResourceBackgroundQueue_abortRequest), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "canHandleRequest", VALUEFUNC(_wrap_ResourceBackgroundQueue_canHandleRequest), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "handleRequest", VALUEFUNC(_wrap_ResourceBackgroundQueue_handleRequest), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "canHandleResponse", VALUEFUNC(_wrap_ResourceBackgroundQueue_canHandleResponse), -1);
  rb_define_method(SwigClassResourceBackgroundQueue.klass, "handleResponse", VALUEFUNC(_wrap_ResourceBackgroundQueue_handleResponse), -1);
  rb_define_singleton_method(SwigClassResourceBackgroundQueue.klass, "getSingleton", VALUEFUNC(_wrap_ResourceBackgroundQueue_getSingleton), -1);
  rb_define_singleton_method(SwigClassResourceBackgroundQueue.klass, "getSingletonPtr", VALUEFUNC(_wrap_ResourceBackgroundQueue_getSingletonPtr), -1);
  SwigClassResourceBackgroundQueue.mark = 0;
  SwigClassResourceBackgroundQueue.destroy = (void (*)(void *)) free_Ogre_ResourceBackgroundQueue;
  SwigClassResourceBackgroundQueue.trackObjects = 0;
  
  SwigClassRibbonTrail.klass = rb_define_class_under(mOgre, "RibbonTrail", ((swig_class *) SWIGTYPE_p_Ogre__BillboardChain->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RibbonTrail, (void *) &SwigClassRibbonTrail);
  rb_define_alloc_func(SwigClassRibbonTrail.klass, _wrap_RibbonTrail_allocate);
  rb_define_method(SwigClassRibbonTrail.klass, "initialize", VALUEFUNC(_wrap_new_RibbonTrail), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "addNode", VALUEFUNC(_wrap_RibbonTrail_addNode), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "removeNode", VALUEFUNC(_wrap_RibbonTrail_removeNode), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getNodeIterator", VALUEFUNC(_wrap_RibbonTrail_getNodeIterator), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getChainIndexForNode", VALUEFUNC(_wrap_RibbonTrail_getChainIndexForNode), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "setTrailLength", VALUEFUNC(_wrap_RibbonTrail_setTrailLength), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getTrailLength", VALUEFUNC(_wrap_RibbonTrail_getTrailLength), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "setMaxChainElements", VALUEFUNC(_wrap_RibbonTrail_setMaxChainElements), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "setNumberOfChains", VALUEFUNC(_wrap_RibbonTrail_setNumberOfChains), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "clearChain", VALUEFUNC(_wrap_RibbonTrail_clearChain), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "setInitialColour", VALUEFUNC(_wrap_RibbonTrail_setInitialColour), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getInitialColour", VALUEFUNC(_wrap_RibbonTrail_getInitialColour), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "setInitialWidth", VALUEFUNC(_wrap_RibbonTrail_setInitialWidth), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getInitialWidth", VALUEFUNC(_wrap_RibbonTrail_getInitialWidth), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "setWidthChange", VALUEFUNC(_wrap_RibbonTrail_setWidthChange), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getWidthChange", VALUEFUNC(_wrap_RibbonTrail_getWidthChange), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "setColourChange", VALUEFUNC(_wrap_RibbonTrail_setColourChange), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getColourChange", VALUEFUNC(_wrap_RibbonTrail_getColourChange), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "nodeUpdated", VALUEFUNC(_wrap_RibbonTrail_nodeUpdated), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "nodeDestroyed", VALUEFUNC(_wrap_RibbonTrail_nodeDestroyed), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "_timeUpdate", VALUEFUNC(_wrap_RibbonTrail__timeUpdate), -1);
  rb_define_method(SwigClassRibbonTrail.klass, "getMovableType", VALUEFUNC(_wrap_RibbonTrail_getMovableType), -1);
  rb_define_singleton_method(SwigClassRibbonTrail.klass, "cast", VALUEFUNC(_wrap_RibbonTrail_cast), -1);
  SwigClassRibbonTrail.mark = 0;
  SwigClassRibbonTrail.destroy = (void (*)(void *)) free_Ogre_RibbonTrail;
  SwigClassRibbonTrail.trackObjects = 0;
  
  SwigClassRibbonTrailFactory.klass = rb_define_class_under(mOgre, "RibbonTrailFactory", ((swig_class *) SWIGTYPE_p_Ogre__MovableObjectFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RibbonTrailFactory, (void *) &SwigClassRibbonTrailFactory);
  rb_undef_alloc_func(SwigClassRibbonTrailFactory.klass);
  rb_define_singleton_method(SwigClassRibbonTrailFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_RibbonTrailFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_singleton_method(SwigClassRibbonTrailFactory.klass, "FACTORY_TYPE_NAME=", VALUEFUNC(_wrap_RibbonTrailFactory_FACTORY_TYPE_NAME_set), 1);
  rb_define_method(SwigClassRibbonTrailFactory.klass, "getType", VALUEFUNC(_wrap_RibbonTrailFactory_getType), -1);
  rb_define_method(SwigClassRibbonTrailFactory.klass, "destroyInstance", VALUEFUNC(_wrap_RibbonTrailFactory_destroyInstance), -1);
  SwigClassRibbonTrailFactory.mark = 0;
  SwigClassRibbonTrailFactory.destroy = (void (*)(void *)) free_Ogre_RibbonTrailFactory;
  SwigClassRibbonTrailFactory.trackObjects = 0;
  
  SwigClassSceneNode.klass = rb_define_class_under(mOgre, "SceneNode", ((swig_class *) SWIGTYPE_p_Ogre__Node->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneNode, (void *) &SwigClassSceneNode);
  rb_define_alloc_func(SwigClassSceneNode.klass, _wrap_SceneNode_allocate);
  rb_define_method(SwigClassSceneNode.klass, "initialize", VALUEFUNC(_wrap_new_SceneNode), -1);
  rb_define_method(SwigClassSceneNode.klass, "attachObject", VALUEFUNC(_wrap_SceneNode_attachObject), -1);
  rb_define_method(SwigClassSceneNode.klass, "numAttachedObjects", VALUEFUNC(_wrap_SceneNode_numAttachedObjects), -1);
  rb_define_method(SwigClassSceneNode.klass, "getAttachedObject", VALUEFUNC(_wrap_SceneNode_getAttachedObject), -1);
  rb_define_method(SwigClassSceneNode.klass, "detachObject", VALUEFUNC(_wrap_SceneNode_detachObject), -1);
  rb_define_method(SwigClassSceneNode.klass, "detachAllObjects", VALUEFUNC(_wrap_SceneNode_detachAllObjects), -1);
  rb_define_method(SwigClassSceneNode.klass, "isInSceneGraph", VALUEFUNC(_wrap_SceneNode_isInSceneGraph), -1);
  rb_define_method(SwigClassSceneNode.klass, "_notifyRootNode", VALUEFUNC(_wrap_SceneNode__notifyRootNode), -1);
  rb_define_method(SwigClassSceneNode.klass, "_update", VALUEFUNC(_wrap_SceneNode__update), -1);
  rb_define_method(SwigClassSceneNode.klass, "_updateBounds", VALUEFUNC(_wrap_SceneNode__updateBounds), -1);
  rb_define_method(SwigClassSceneNode.klass, "_findVisibleObjects", VALUEFUNC(_wrap_SceneNode__findVisibleObjects), -1);
  rb_define_method(SwigClassSceneNode.klass, "_getWorldAABB", VALUEFUNC(_wrap_SceneNode__getWorldAABB), -1);
  rb_define_method(SwigClassSceneNode.klass, "getCreator", VALUEFUNC(_wrap_SceneNode_getCreator), -1);
  rb_define_method(SwigClassSceneNode.klass, "removeAndDestroyChild", VALUEFUNC(_wrap_SceneNode_removeAndDestroyChild), -1);
  rb_define_method(SwigClassSceneNode.klass, "removeAndDestroyAllChildren", VALUEFUNC(_wrap_SceneNode_removeAndDestroyAllChildren), -1);
  rb_define_method(SwigClassSceneNode.klass, "showBoundingBox", VALUEFUNC(_wrap_SceneNode_showBoundingBox), -1);
  rb_define_method(SwigClassSceneNode.klass, "hideBoundingBox", VALUEFUNC(_wrap_SceneNode_hideBoundingBox), -1);
  rb_define_method(SwigClassSceneNode.klass, "_addBoundingBoxToQueue", VALUEFUNC(_wrap_SceneNode__addBoundingBoxToQueue), -1);
  rb_define_method(SwigClassSceneNode.klass, "getShowBoundingBox", VALUEFUNC(_wrap_SceneNode_getShowBoundingBox), -1);
  rb_define_method(SwigClassSceneNode.klass, "createChildSceneNode", VALUEFUNC(_wrap_SceneNode_createChildSceneNode), -1);
  rb_define_method(SwigClassSceneNode.klass, "findLights", VALUEFUNC(_wrap_SceneNode_findLights), -1);
  rb_define_method(SwigClassSceneNode.klass, "setFixedYawAxis", VALUEFUNC(_wrap_SceneNode_setFixedYawAxis), -1);
  rb_define_method(SwigClassSceneNode.klass, "yaw", VALUEFUNC(_wrap_SceneNode_yaw), -1);
  rb_define_method(SwigClassSceneNode.klass, "setDirection", VALUEFUNC(_wrap_SceneNode_setDirection), -1);
  rb_define_method(SwigClassSceneNode.klass, "lookAt", VALUEFUNC(_wrap_SceneNode_lookAt), -1);
  rb_define_method(SwigClassSceneNode.klass, "setAutoTracking", VALUEFUNC(_wrap_SceneNode_setAutoTracking), -1);
  rb_define_method(SwigClassSceneNode.klass, "getAutoTrackTarget", VALUEFUNC(_wrap_SceneNode_getAutoTrackTarget), -1);
  rb_define_method(SwigClassSceneNode.klass, "getAutoTrackOffset", VALUEFUNC(_wrap_SceneNode_getAutoTrackOffset), -1);
  rb_define_method(SwigClassSceneNode.klass, "getAutoTrackLocalDirection", VALUEFUNC(_wrap_SceneNode_getAutoTrackLocalDirection), -1);
  rb_define_method(SwigClassSceneNode.klass, "_autoTrack", VALUEFUNC(_wrap_SceneNode__autoTrack), -1);
  rb_define_method(SwigClassSceneNode.klass, "getParentSceneNode", VALUEFUNC(_wrap_SceneNode_getParentSceneNode), -1);
  rb_define_method(SwigClassSceneNode.klass, "setVisible", VALUEFUNC(_wrap_SceneNode_setVisible), -1);
  rb_define_method(SwigClassSceneNode.klass, "flipVisibility", VALUEFUNC(_wrap_SceneNode_flipVisibility), -1);
  rb_define_method(SwigClassSceneNode.klass, "setDebugDisplayEnabled", VALUEFUNC(_wrap_SceneNode_setDebugDisplayEnabled), -1);
  rb_define_method(SwigClassSceneNode.klass, "getDebugRenderable", VALUEFUNC(_wrap_SceneNode_getDebugRenderable), -1);
  SwigClassSceneNode.mark = 0;
  SwigClassSceneNode.destroy = (void (*)(void *)) free_Ogre_SceneNode;
  SwigClassSceneNode.trackObjects = 0;
  
  SwigClassSceneQuery.klass = rb_define_class_under(mOgre, "SceneQuery", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneQuery, (void *) &SwigClassSceneQuery);
  rb_define_alloc_func(SwigClassSceneQuery.klass, _wrap_SceneQuery_allocate);
  rb_define_method(SwigClassSceneQuery.klass, "initialize", VALUEFUNC(_wrap_new_SceneQuery), -1);
  rb_define_const(SwigClassSceneQuery.klass, "WFT_NONE", SWIG_From_int(static_cast< int >(Ogre::SceneQuery::WFT_NONE)));
  rb_define_const(SwigClassSceneQuery.klass, "WFT_PLANE_BOUNDED_REGION", SWIG_From_int(static_cast< int >(Ogre::SceneQuery::WFT_PLANE_BOUNDED_REGION)));
  rb_define_const(SwigClassSceneQuery.klass, "WFT_SINGLE_INTERSECTION", SWIG_From_int(static_cast< int >(Ogre::SceneQuery::WFT_SINGLE_INTERSECTION)));
  rb_define_const(SwigClassSceneQuery.klass, "WFT_CUSTOM_GEOMETRY", SWIG_From_int(static_cast< int >(Ogre::SceneQuery::WFT_CUSTOM_GEOMETRY)));
  rb_define_const(SwigClassSceneQuery.klass, "WFT_RENDER_OPERATION", SWIG_From_int(static_cast< int >(Ogre::SceneQuery::WFT_RENDER_OPERATION)));
  rb_define_method(SwigClassSceneQuery.klass, "setQueryMask", VALUEFUNC(_wrap_SceneQuery_setQueryMask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "getQueryMask", VALUEFUNC(_wrap_SceneQuery_getQueryMask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "setQueryTypeMask", VALUEFUNC(_wrap_SceneQuery_setQueryTypeMask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "getQueryTypeMask", VALUEFUNC(_wrap_SceneQuery_getQueryTypeMask), -1);
  rb_define_method(SwigClassSceneQuery.klass, "setWorldFragmentType", VALUEFUNC(_wrap_SceneQuery_setWorldFragmentType), -1);
  rb_define_method(SwigClassSceneQuery.klass, "getWorldFragmentType", VALUEFUNC(_wrap_SceneQuery_getWorldFragmentType), -1);
  rb_define_method(SwigClassSceneQuery.klass, "getSupportedWorldFragmentTypes", VALUEFUNC(_wrap_SceneQuery_getSupportedWorldFragmentTypes), -1);
  SwigClassSceneQuery.mark = 0;
  SwigClassSceneQuery.destroy = (void (*)(void *)) free_Ogre_SceneQuery;
  SwigClassSceneQuery.trackObjects = 0;
  
  SwigClassSceneQueryListener.klass = rb_define_class_under(mOgre, "SceneQueryListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneQueryListener, (void *) &SwigClassSceneQueryListener);
  rb_undef_alloc_func(SwigClassSceneQueryListener.klass);
  rb_define_method(SwigClassSceneQueryListener.klass, "queryResult", VALUEFUNC(_wrap_SceneQueryListener_queryResult), -1);
  SwigClassSceneQueryListener.mark = 0;
  SwigClassSceneQueryListener.destroy = (void (*)(void *)) free_Ogre_SceneQueryListener;
  SwigClassSceneQueryListener.trackObjects = 0;
  
  SwigClassSceneQueryResult.klass = rb_define_class_under(mOgre, "SceneQueryResult", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneQueryResult, (void *) &SwigClassSceneQueryResult);
  rb_define_alloc_func(SwigClassSceneQueryResult.klass, _wrap_SceneQueryResult_allocate);
  rb_define_method(SwigClassSceneQueryResult.klass, "initialize", VALUEFUNC(_wrap_new_SceneQueryResult), -1);
  rb_define_method(SwigClassSceneQueryResult.klass, "movables=", VALUEFUNC(_wrap_SceneQueryResult_movables_set), -1);
  rb_define_method(SwigClassSceneQueryResult.klass, "movables", VALUEFUNC(_wrap_SceneQueryResult_movables_get), -1);
  rb_define_method(SwigClassSceneQueryResult.klass, "worldFragments=", VALUEFUNC(_wrap_SceneQueryResult_worldFragments_set), -1);
  rb_define_method(SwigClassSceneQueryResult.klass, "worldFragments", VALUEFUNC(_wrap_SceneQueryResult_worldFragments_get), -1);
  SwigClassSceneQueryResult.mark = 0;
  SwigClassSceneQueryResult.destroy = (void (*)(void *)) free_Ogre_SceneQueryResult;
  SwigClassSceneQueryResult.trackObjects = 0;
  
  SwigClassRegionSceneQuery.klass = rb_define_class_under(mOgre, "RegionSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__SceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RegionSceneQuery, (void *) &SwigClassRegionSceneQuery);
  rb_undef_alloc_func(SwigClassRegionSceneQuery.klass);
  rb_define_method(SwigClassRegionSceneQuery.klass, "execute", VALUEFUNC(_wrap_RegionSceneQuery_execute), -1);
  rb_define_method(SwigClassRegionSceneQuery.klass, "getLastResults", VALUEFUNC(_wrap_RegionSceneQuery_getLastResults), -1);
  rb_define_method(SwigClassRegionSceneQuery.klass, "clearResults", VALUEFUNC(_wrap_RegionSceneQuery_clearResults), -1);
  rb_define_method(SwigClassRegionSceneQuery.klass, "queryResult", VALUEFUNC(_wrap_RegionSceneQuery_queryResult), -1);
  SwigClassRegionSceneQuery.mark = 0;
  SwigClassRegionSceneQuery.destroy = (void (*)(void *)) free_Ogre_RegionSceneQuery;
  SwigClassRegionSceneQuery.trackObjects = 0;
  
  SwigClassAxisAlignedBoxSceneQuery.klass = rb_define_class_under(mOgre, "AxisAlignedBoxSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__RegionSceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__AxisAlignedBoxSceneQuery, (void *) &SwigClassAxisAlignedBoxSceneQuery);
  rb_undef_alloc_func(SwigClassAxisAlignedBoxSceneQuery.klass);
  rb_define_method(SwigClassAxisAlignedBoxSceneQuery.klass, "setBox", VALUEFUNC(_wrap_AxisAlignedBoxSceneQuery_setBox), -1);
  rb_define_method(SwigClassAxisAlignedBoxSceneQuery.klass, "getBox", VALUEFUNC(_wrap_AxisAlignedBoxSceneQuery_getBox), -1);
  SwigClassAxisAlignedBoxSceneQuery.mark = 0;
  SwigClassAxisAlignedBoxSceneQuery.destroy = (void (*)(void *)) free_Ogre_AxisAlignedBoxSceneQuery;
  SwigClassAxisAlignedBoxSceneQuery.trackObjects = 0;
  
  SwigClassSphereSceneQuery.klass = rb_define_class_under(mOgre, "SphereSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__RegionSceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SphereSceneQuery, (void *) &SwigClassSphereSceneQuery);
  rb_undef_alloc_func(SwigClassSphereSceneQuery.klass);
  rb_define_method(SwigClassSphereSceneQuery.klass, "setSphere", VALUEFUNC(_wrap_SphereSceneQuery_setSphere), -1);
  rb_define_method(SwigClassSphereSceneQuery.klass, "getSphere", VALUEFUNC(_wrap_SphereSceneQuery_getSphere), -1);
  SwigClassSphereSceneQuery.mark = 0;
  SwigClassSphereSceneQuery.destroy = (void (*)(void *)) free_Ogre_SphereSceneQuery;
  SwigClassSphereSceneQuery.trackObjects = 0;
  
  SwigClassPlaneBoundedVolumeListSceneQuery.klass = rb_define_class_under(mOgre, "PlaneBoundedVolumeListSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__RegionSceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PlaneBoundedVolumeListSceneQuery, (void *) &SwigClassPlaneBoundedVolumeListSceneQuery);
  rb_undef_alloc_func(SwigClassPlaneBoundedVolumeListSceneQuery.klass);
  rb_define_method(SwigClassPlaneBoundedVolumeListSceneQuery.klass, "setVolumes", VALUEFUNC(_wrap_PlaneBoundedVolumeListSceneQuery_setVolumes), -1);
  rb_define_method(SwigClassPlaneBoundedVolumeListSceneQuery.klass, "getVolumes", VALUEFUNC(_wrap_PlaneBoundedVolumeListSceneQuery_getVolumes), -1);
  SwigClassPlaneBoundedVolumeListSceneQuery.mark = 0;
  SwigClassPlaneBoundedVolumeListSceneQuery.destroy = (void (*)(void *)) free_Ogre_PlaneBoundedVolumeListSceneQuery;
  SwigClassPlaneBoundedVolumeListSceneQuery.trackObjects = 0;
  
  SwigClassRaySceneQueryListener.klass = rb_define_class_under(mOgre, "RaySceneQueryListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RaySceneQueryListener, (void *) &SwigClassRaySceneQueryListener);
  rb_undef_alloc_func(SwigClassRaySceneQueryListener.klass);
  rb_define_method(SwigClassRaySceneQueryListener.klass, "queryResult", VALUEFUNC(_wrap_RaySceneQueryListener_queryResult), -1);
  SwigClassRaySceneQueryListener.mark = 0;
  SwigClassRaySceneQueryListener.destroy = (void (*)(void *)) free_Ogre_RaySceneQueryListener;
  SwigClassRaySceneQueryListener.trackObjects = 0;
  
  SwigClassRaySceneQueryResultEntry.klass = rb_define_class_under(mOgre, "RaySceneQueryResultEntry", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RaySceneQueryResultEntry, (void *) &SwigClassRaySceneQueryResultEntry);
  rb_define_alloc_func(SwigClassRaySceneQueryResultEntry.klass, _wrap_RaySceneQueryResultEntry_allocate);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "initialize", VALUEFUNC(_wrap_new_RaySceneQueryResultEntry), -1);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "distance=", VALUEFUNC(_wrap_RaySceneQueryResultEntry_distance_set), -1);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "distance", VALUEFUNC(_wrap_RaySceneQueryResultEntry_distance_get), -1);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "movable=", VALUEFUNC(_wrap_RaySceneQueryResultEntry_movable_set), -1);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "movable", VALUEFUNC(_wrap_RaySceneQueryResultEntry_movable_get), -1);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "worldFragment=", VALUEFUNC(_wrap_RaySceneQueryResultEntry_worldFragment_set), -1);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "worldFragment", VALUEFUNC(_wrap_RaySceneQueryResultEntry_worldFragment_get), -1);
  rb_define_method(SwigClassRaySceneQueryResultEntry.klass, "<", VALUEFUNC(_wrap_RaySceneQueryResultEntry___lt__), -1);
  SwigClassRaySceneQueryResultEntry.mark = 0;
  SwigClassRaySceneQueryResultEntry.destroy = (void (*)(void *)) free_Ogre_RaySceneQueryResultEntry;
  SwigClassRaySceneQueryResultEntry.trackObjects = 0;
  
  SwigClassRaySceneQuery.klass = rb_define_class_under(mOgre, "RaySceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__SceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__RaySceneQuery, (void *) &SwigClassRaySceneQuery);
  rb_undef_alloc_func(SwigClassRaySceneQuery.klass);
  rb_define_method(SwigClassRaySceneQuery.klass, "setRay", VALUEFUNC(_wrap_RaySceneQuery_setRay), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "getRay", VALUEFUNC(_wrap_RaySceneQuery_getRay), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "setSortByDistance", VALUEFUNC(_wrap_RaySceneQuery_setSortByDistance), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "getSortByDistance", VALUEFUNC(_wrap_RaySceneQuery_getSortByDistance), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "getMaxResults", VALUEFUNC(_wrap_RaySceneQuery_getMaxResults), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "execute", VALUEFUNC(_wrap_RaySceneQuery_execute), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "getLastResults", VALUEFUNC(_wrap_RaySceneQuery_getLastResults), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "clearResults", VALUEFUNC(_wrap_RaySceneQuery_clearResults), -1);
  rb_define_method(SwigClassRaySceneQuery.klass, "queryResult", VALUEFUNC(_wrap_RaySceneQuery_queryResult), -1);
  SwigClassRaySceneQuery.mark = 0;
  SwigClassRaySceneQuery.destroy = (void (*)(void *)) free_Ogre_RaySceneQuery;
  SwigClassRaySceneQuery.trackObjects = 0;
  
  SwigClassIntersectionSceneQueryListener.klass = rb_define_class_under(mOgre, "IntersectionSceneQueryListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__IntersectionSceneQueryListener, (void *) &SwigClassIntersectionSceneQueryListener);
  rb_undef_alloc_func(SwigClassIntersectionSceneQueryListener.klass);
  rb_define_method(SwigClassIntersectionSceneQueryListener.klass, "queryResult", VALUEFUNC(_wrap_IntersectionSceneQueryListener_queryResult), -1);
  SwigClassIntersectionSceneQueryListener.mark = 0;
  SwigClassIntersectionSceneQueryListener.destroy = (void (*)(void *)) free_Ogre_IntersectionSceneQueryListener;
  SwigClassIntersectionSceneQueryListener.trackObjects = 0;
  
  SwigClassIntersectionSceneQueryResult.klass = rb_define_class_under(mOgre, "IntersectionSceneQueryResult", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__IntersectionSceneQueryResult, (void *) &SwigClassIntersectionSceneQueryResult);
  rb_define_alloc_func(SwigClassIntersectionSceneQueryResult.klass, _wrap_IntersectionSceneQueryResult_allocate);
  rb_define_method(SwigClassIntersectionSceneQueryResult.klass, "initialize", VALUEFUNC(_wrap_new_IntersectionSceneQueryResult), -1);
  rb_define_method(SwigClassIntersectionSceneQueryResult.klass, "movables2movables=", VALUEFUNC(_wrap_IntersectionSceneQueryResult_movables2movables_set), -1);
  rb_define_method(SwigClassIntersectionSceneQueryResult.klass, "movables2movables", VALUEFUNC(_wrap_IntersectionSceneQueryResult_movables2movables_get), -1);
  rb_define_method(SwigClassIntersectionSceneQueryResult.klass, "movables2world=", VALUEFUNC(_wrap_IntersectionSceneQueryResult_movables2world_set), -1);
  rb_define_method(SwigClassIntersectionSceneQueryResult.klass, "movables2world", VALUEFUNC(_wrap_IntersectionSceneQueryResult_movables2world_get), -1);
  SwigClassIntersectionSceneQueryResult.mark = 0;
  SwigClassIntersectionSceneQueryResult.destroy = (void (*)(void *)) free_Ogre_IntersectionSceneQueryResult;
  SwigClassIntersectionSceneQueryResult.trackObjects = 0;
  
  SwigClassIntersectionSceneQuery.klass = rb_define_class_under(mOgre, "IntersectionSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__SceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__IntersectionSceneQuery, (void *) &SwigClassIntersectionSceneQuery);
  rb_undef_alloc_func(SwigClassIntersectionSceneQuery.klass);
  rb_define_method(SwigClassIntersectionSceneQuery.klass, "execute", VALUEFUNC(_wrap_IntersectionSceneQuery_execute), -1);
  rb_define_method(SwigClassIntersectionSceneQuery.klass, "getLastResults", VALUEFUNC(_wrap_IntersectionSceneQuery_getLastResults), -1);
  rb_define_method(SwigClassIntersectionSceneQuery.klass, "clearResults", VALUEFUNC(_wrap_IntersectionSceneQuery_clearResults), -1);
  rb_define_method(SwigClassIntersectionSceneQuery.klass, "queryResult", VALUEFUNC(_wrap_IntersectionSceneQuery_queryResult), -1);
  SwigClassIntersectionSceneQuery.mark = 0;
  SwigClassIntersectionSceneQuery.destroy = (void (*)(void *)) free_Ogre_IntersectionSceneQuery;
  SwigClassIntersectionSceneQuery.trackObjects = 0;
  
  SwigClassShadowTextureConfig.klass = rb_define_class_under(mOgre, "ShadowTextureConfig", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ShadowTextureConfig, (void *) &SwigClassShadowTextureConfig);
  rb_define_alloc_func(SwigClassShadowTextureConfig.klass, _wrap_ShadowTextureConfig_allocate);
  rb_define_method(SwigClassShadowTextureConfig.klass, "initialize", VALUEFUNC(_wrap_new_ShadowTextureConfig), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "width=", VALUEFUNC(_wrap_ShadowTextureConfig_width_set), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "width", VALUEFUNC(_wrap_ShadowTextureConfig_width_get), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "height=", VALUEFUNC(_wrap_ShadowTextureConfig_height_set), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "height", VALUEFUNC(_wrap_ShadowTextureConfig_height_get), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "format=", VALUEFUNC(_wrap_ShadowTextureConfig_format_set), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "format", VALUEFUNC(_wrap_ShadowTextureConfig_format_get), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "fsaa=", VALUEFUNC(_wrap_ShadowTextureConfig_fsaa_set), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "fsaa", VALUEFUNC(_wrap_ShadowTextureConfig_fsaa_get), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "depthBufferPoolId=", VALUEFUNC(_wrap_ShadowTextureConfig_depthBufferPoolId_set), -1);
  rb_define_method(SwigClassShadowTextureConfig.klass, "depthBufferPoolId", VALUEFUNC(_wrap_ShadowTextureConfig_depthBufferPoolId_get), -1);
  SwigClassShadowTextureConfig.mark = 0;
  SwigClassShadowTextureConfig.destroy = (void (*)(void *)) free_Ogre_ShadowTextureConfig;
  SwigClassShadowTextureConfig.trackObjects = 0;
  rb_define_module_function(mOgre, "==", VALUEFUNC(_wrap___eq__), -1);
  
  SwigClassShadowTextureManager.klass = rb_define_class_under(mOgre, "ShadowTextureManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ShadowTextureManager, (void *) &SwigClassShadowTextureManager);
  rb_define_alloc_func(SwigClassShadowTextureManager.klass, _wrap_ShadowTextureManager_allocate);
  rb_define_method(SwigClassShadowTextureManager.klass, "initialize", VALUEFUNC(_wrap_new_ShadowTextureManager), -1);
  rb_define_method(SwigClassShadowTextureManager.klass, "getShadowTextures", VALUEFUNC(_wrap_ShadowTextureManager_getShadowTextures), -1);
  rb_define_method(SwigClassShadowTextureManager.klass, "getNullShadowTexture", VALUEFUNC(_wrap_ShadowTextureManager_getNullShadowTexture), -1);
  rb_define_method(SwigClassShadowTextureManager.klass, "clearUnused", VALUEFUNC(_wrap_ShadowTextureManager_clearUnused), -1);
  rb_define_method(SwigClassShadowTextureManager.klass, "clear", VALUEFUNC(_wrap_ShadowTextureManager_clear), -1);
  rb_define_singleton_method(SwigClassShadowTextureManager.klass, "getSingleton", VALUEFUNC(_wrap_ShadowTextureManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassShadowTextureManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_ShadowTextureManager_getSingletonPtr), -1);
  SwigClassShadowTextureManager.mark = 0;
  SwigClassShadowTextureManager.destroy = (void (*)(void *)) free_Ogre_ShadowTextureManager;
  SwigClassShadowTextureManager.trackObjects = 0;
  
  SwigClassViewPoint.klass = rb_define_class_under(mOgre, "ViewPoint", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ViewPoint, (void *) &SwigClassViewPoint);
  rb_define_alloc_func(SwigClassViewPoint.klass, _wrap_ViewPoint_allocate);
  rb_define_method(SwigClassViewPoint.klass, "initialize", VALUEFUNC(_wrap_new_ViewPoint), -1);
  rb_define_method(SwigClassViewPoint.klass, "position=", VALUEFUNC(_wrap_ViewPoint_position_set), -1);
  rb_define_method(SwigClassViewPoint.klass, "position", VALUEFUNC(_wrap_ViewPoint_position_get), -1);
  rb_define_method(SwigClassViewPoint.klass, "orientation=", VALUEFUNC(_wrap_ViewPoint_orientation_set), -1);
  rb_define_method(SwigClassViewPoint.klass, "orientation", VALUEFUNC(_wrap_ViewPoint_orientation_get), -1);
  SwigClassViewPoint.mark = 0;
  SwigClassViewPoint.destroy = (void (*)(void *)) free_Ogre_ViewPoint;
  SwigClassViewPoint.trackObjects = 0;
  
  SwigClassVisibleObjectsBoundsInfo.klass = rb_define_class_under(mOgre, "VisibleObjectsBoundsInfo", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__VisibleObjectsBoundsInfo, (void *) &SwigClassVisibleObjectsBoundsInfo);
  rb_define_alloc_func(SwigClassVisibleObjectsBoundsInfo.klass, _wrap_VisibleObjectsBoundsInfo_allocate);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "initialize", VALUEFUNC(_wrap_new_VisibleObjectsBoundsInfo), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "aabb=", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_aabb_set), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "aabb", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_aabb_get), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "receiverAabb=", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_receiverAabb_set), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "receiverAabb", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_receiverAabb_get), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "minDistance=", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_minDistance_set), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "minDistance", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_minDistance_get), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "maxDistance=", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_maxDistance_set), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "maxDistance", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_maxDistance_get), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "minDistanceInFrustum=", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_minDistanceInFrustum_set), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "minDistanceInFrustum", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_minDistanceInFrustum_get), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "maxDistanceInFrustum=", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_maxDistanceInFrustum_set), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "maxDistanceInFrustum", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_maxDistanceInFrustum_get), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "reset", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_reset), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "merge", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_merge), -1);
  rb_define_method(SwigClassVisibleObjectsBoundsInfo.klass, "mergeNonRenderedButInFrustum", VALUEFUNC(_wrap_VisibleObjectsBoundsInfo_mergeNonRenderedButInFrustum), -1);
  SwigClassVisibleObjectsBoundsInfo.mark = 0;
  SwigClassVisibleObjectsBoundsInfo.destroy = (void (*)(void *)) free_Ogre_VisibleObjectsBoundsInfo;
  SwigClassVisibleObjectsBoundsInfo.trackObjects = 0;
  
  SwigClassSceneManager.klass = rb_define_class_under(mOgre, "SceneManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneManager, (void *) &SwigClassSceneManager);
  rb_undef_alloc_func(SwigClassSceneManager.klass);
  rb_define_singleton_method(SwigClassSceneManager.klass, "WORLD_GEOMETRY_TYPE_MASK", VALUEFUNC(_wrap_SceneManager_WORLD_GEOMETRY_TYPE_MASK_get), 0);
  rb_define_singleton_method(SwigClassSceneManager.klass, "WORLD_GEOMETRY_TYPE_MASK=", VALUEFUNC(_wrap_SceneManager_WORLD_GEOMETRY_TYPE_MASK_set), 1);
  rb_define_singleton_method(SwigClassSceneManager.klass, "ENTITY_TYPE_MASK", VALUEFUNC(_wrap_SceneManager_ENTITY_TYPE_MASK_get), 0);
  rb_define_singleton_method(SwigClassSceneManager.klass, "ENTITY_TYPE_MASK=", VALUEFUNC(_wrap_SceneManager_ENTITY_TYPE_MASK_set), 1);
  rb_define_singleton_method(SwigClassSceneManager.klass, "FX_TYPE_MASK", VALUEFUNC(_wrap_SceneManager_FX_TYPE_MASK_get), 0);
  rb_define_singleton_method(SwigClassSceneManager.klass, "FX_TYPE_MASK=", VALUEFUNC(_wrap_SceneManager_FX_TYPE_MASK_set), 1);
  rb_define_singleton_method(SwigClassSceneManager.klass, "STATICGEOMETRY_TYPE_MASK", VALUEFUNC(_wrap_SceneManager_STATICGEOMETRY_TYPE_MASK_get), 0);
  rb_define_singleton_method(SwigClassSceneManager.klass, "STATICGEOMETRY_TYPE_MASK=", VALUEFUNC(_wrap_SceneManager_STATICGEOMETRY_TYPE_MASK_set), 1);
  rb_define_singleton_method(SwigClassSceneManager.klass, "LIGHT_TYPE_MASK", VALUEFUNC(_wrap_SceneManager_LIGHT_TYPE_MASK_get), 0);
  rb_define_singleton_method(SwigClassSceneManager.klass, "LIGHT_TYPE_MASK=", VALUEFUNC(_wrap_SceneManager_LIGHT_TYPE_MASK_set), 1);
  rb_define_singleton_method(SwigClassSceneManager.klass, "FRUSTUM_TYPE_MASK", VALUEFUNC(_wrap_SceneManager_FRUSTUM_TYPE_MASK_get), 0);
  rb_define_singleton_method(SwigClassSceneManager.klass, "FRUSTUM_TYPE_MASK=", VALUEFUNC(_wrap_SceneManager_FRUSTUM_TYPE_MASK_set), 1);
  rb_define_singleton_method(SwigClassSceneManager.klass, "USER_TYPE_MASK_LIMIT", VALUEFUNC(_wrap_SceneManager_USER_TYPE_MASK_LIMIT_get), 0);
  rb_define_singleton_method(SwigClassSceneManager.klass, "USER_TYPE_MASK_LIMIT=", VALUEFUNC(_wrap_SceneManager_USER_TYPE_MASK_LIMIT_set), 1);
  rb_define_const(SwigClassSceneManager.klass, "IRS_NONE", SWIG_From_int(static_cast< int >(Ogre::SceneManager::IRS_NONE)));
  rb_define_const(SwigClassSceneManager.klass, "IRS_RENDER_TO_TEXTURE", SWIG_From_int(static_cast< int >(Ogre::SceneManager::IRS_RENDER_TO_TEXTURE)));
  rb_define_const(SwigClassSceneManager.klass, "IRS_RENDER_RECEIVER_PASS", SWIG_From_int(static_cast< int >(Ogre::SceneManager::IRS_RENDER_RECEIVER_PASS)));
  rb_define_const(SwigClassSceneManager.klass, "SCRQM_INCLUDE", SWIG_From_int(static_cast< int >(Ogre::SceneManager::SCRQM_INCLUDE)));
  rb_define_const(SwigClassSceneManager.klass, "SCRQM_EXCLUDE", SWIG_From_int(static_cast< int >(Ogre::SceneManager::SCRQM_EXCLUDE)));
  rb_define_method(SwigClassSceneManager.klass, "prepareShadowTextures", VALUEFUNC(_wrap_SceneManager_prepareShadowTextures), -1);
  rb_define_method(SwigClassSceneManager.klass, "_pauseRendering", VALUEFUNC(_wrap_SceneManager__pauseRendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "_resumeRendering", VALUEFUNC(_wrap_SceneManager__resumeRendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "getName", VALUEFUNC(_wrap_SceneManager_getName), -1);
  rb_define_method(SwigClassSceneManager.klass, "getTypeName", VALUEFUNC(_wrap_SceneManager_getTypeName), -1);
  rb_define_method(SwigClassSceneManager.klass, "createCamera", VALUEFUNC(_wrap_SceneManager_createCamera), -1);
  rb_define_method(SwigClassSceneManager.klass, "getCamera", VALUEFUNC(_wrap_SceneManager_getCamera), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasCamera", VALUEFUNC(_wrap_SceneManager_hasCamera), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyCamera", VALUEFUNC(_wrap_SceneManager_destroyCamera), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllCameras", VALUEFUNC(_wrap_SceneManager_destroyAllCameras), -1);
  rb_define_method(SwigClassSceneManager.klass, "createLight", VALUEFUNC(_wrap_SceneManager_createLight), -1);
  rb_define_method(SwigClassSceneManager.klass, "getLight", VALUEFUNC(_wrap_SceneManager_getLight), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasLight", VALUEFUNC(_wrap_SceneManager_hasLight), -1);
  rb_define_method(SwigClassSceneManager.klass, "getLightClippingPlanes", VALUEFUNC(_wrap_SceneManager_getLightClippingPlanes), -1);
  rb_define_method(SwigClassSceneManager.klass, "getLightScissorRect", VALUEFUNC(_wrap_SceneManager_getLightScissorRect), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyLight", VALUEFUNC(_wrap_SceneManager_destroyLight), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllLights", VALUEFUNC(_wrap_SceneManager_destroyAllLights), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notifyLightsDirty", VALUEFUNC(_wrap_SceneManager__notifyLightsDirty), -1);
  rb_define_method(SwigClassSceneManager.klass, "_getLightsDirtyCounter", VALUEFUNC(_wrap_SceneManager__getLightsDirtyCounter), -1);
  rb_define_method(SwigClassSceneManager.klass, "_getLightsAffectingFrustum", VALUEFUNC(_wrap_SceneManager__getLightsAffectingFrustum), -1);
  rb_define_method(SwigClassSceneManager.klass, "_populateLightList", VALUEFUNC(_wrap_SceneManager__populateLightList), -1);
  rb_define_method(SwigClassSceneManager.klass, "createSceneNode", VALUEFUNC(_wrap_SceneManager_createSceneNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroySceneNode", VALUEFUNC(_wrap_SceneManager_destroySceneNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "getRootSceneNode", VALUEFUNC(_wrap_SceneManager_getRootSceneNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSceneNode", VALUEFUNC(_wrap_SceneManager_getSceneNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasSceneNode", VALUEFUNC(_wrap_SceneManager_hasSceneNode), -1);
  rb_define_const(SwigClassSceneManager.klass, "PT_PLANE", SWIG_From_int(static_cast< int >(Ogre::SceneManager::PT_PLANE)));
  rb_define_const(SwigClassSceneManager.klass, "PT_CUBE", SWIG_From_int(static_cast< int >(Ogre::SceneManager::PT_CUBE)));
  rb_define_const(SwigClassSceneManager.klass, "PT_SPHERE", SWIG_From_int(static_cast< int >(Ogre::SceneManager::PT_SPHERE)));
  rb_define_method(SwigClassSceneManager.klass, "createEntity", VALUEFUNC(_wrap_SceneManager_createEntity), -1);
  rb_define_method(SwigClassSceneManager.klass, "getEntity", VALUEFUNC(_wrap_SceneManager_getEntity), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasEntity", VALUEFUNC(_wrap_SceneManager_hasEntity), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyEntity", VALUEFUNC(_wrap_SceneManager_destroyEntity), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllEntities", VALUEFUNC(_wrap_SceneManager_destroyAllEntities), -1);
  rb_define_method(SwigClassSceneManager.klass, "createManualObject", VALUEFUNC(_wrap_SceneManager_createManualObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "getManualObject", VALUEFUNC(_wrap_SceneManager_getManualObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasManualObject", VALUEFUNC(_wrap_SceneManager_hasManualObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyManualObject", VALUEFUNC(_wrap_SceneManager_destroyManualObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllManualObjects", VALUEFUNC(_wrap_SceneManager_destroyAllManualObjects), -1);
  rb_define_method(SwigClassSceneManager.klass, "createBillboardChain", VALUEFUNC(_wrap_SceneManager_createBillboardChain), -1);
  rb_define_method(SwigClassSceneManager.klass, "getBillboardChain", VALUEFUNC(_wrap_SceneManager_getBillboardChain), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasBillboardChain", VALUEFUNC(_wrap_SceneManager_hasBillboardChain), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyBillboardChain", VALUEFUNC(_wrap_SceneManager_destroyBillboardChain), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllBillboardChains", VALUEFUNC(_wrap_SceneManager_destroyAllBillboardChains), -1);
  rb_define_method(SwigClassSceneManager.klass, "createRibbonTrail", VALUEFUNC(_wrap_SceneManager_createRibbonTrail), -1);
  rb_define_method(SwigClassSceneManager.klass, "getRibbonTrail", VALUEFUNC(_wrap_SceneManager_getRibbonTrail), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasRibbonTrail", VALUEFUNC(_wrap_SceneManager_hasRibbonTrail), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyRibbonTrail", VALUEFUNC(_wrap_SceneManager_destroyRibbonTrail), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllRibbonTrails", VALUEFUNC(_wrap_SceneManager_destroyAllRibbonTrails), -1);
  rb_define_method(SwigClassSceneManager.klass, "createParticleSystem", VALUEFUNC(_wrap_SceneManager_createParticleSystem), -1);
  rb_define_method(SwigClassSceneManager.klass, "getParticleSystem", VALUEFUNC(_wrap_SceneManager_getParticleSystem), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasParticleSystem", VALUEFUNC(_wrap_SceneManager_hasParticleSystem), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyParticleSystem", VALUEFUNC(_wrap_SceneManager_destroyParticleSystem), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllParticleSystems", VALUEFUNC(_wrap_SceneManager_destroyAllParticleSystems), -1);
  rb_define_method(SwigClassSceneManager.klass, "clearScene", VALUEFUNC(_wrap_SceneManager_clearScene), -1);
  rb_define_method(SwigClassSceneManager.klass, "setAmbientLight", VALUEFUNC(_wrap_SceneManager_setAmbientLight), -1);
  rb_define_method(SwigClassSceneManager.klass, "getAmbientLight", VALUEFUNC(_wrap_SceneManager_getAmbientLight), -1);
  rb_define_method(SwigClassSceneManager.klass, "prepareWorldGeometry", VALUEFUNC(_wrap_SceneManager_prepareWorldGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "setWorldGeometry", VALUEFUNC(_wrap_SceneManager_setWorldGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "estimateWorldGeometry", VALUEFUNC(_wrap_SceneManager_estimateWorldGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSuggestedViewpoint", VALUEFUNC(_wrap_SceneManager_getSuggestedViewpoint), -1);
  rb_define_method(SwigClassSceneManager.klass, "setOption", VALUEFUNC(_wrap_SceneManager_setOption), -1);
  rb_define_method(SwigClassSceneManager.klass, "getOption", VALUEFUNC(_wrap_SceneManager_getOption), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasOption", VALUEFUNC(_wrap_SceneManager_hasOption), -1);
  rb_define_method(SwigClassSceneManager.klass, "getOptionValues", VALUEFUNC(_wrap_SceneManager_getOptionValues), -1);
  rb_define_method(SwigClassSceneManager.klass, "getOptionKeys", VALUEFUNC(_wrap_SceneManager_getOptionKeys), -1);
  rb_define_method(SwigClassSceneManager.klass, "_updateSceneGraph", VALUEFUNC(_wrap_SceneManager__updateSceneGraph), -1);
  rb_define_method(SwigClassSceneManager.klass, "_findVisibleObjects", VALUEFUNC(_wrap_SceneManager__findVisibleObjects), -1);
  rb_define_method(SwigClassSceneManager.klass, "_applySceneAnimations", VALUEFUNC(_wrap_SceneManager__applySceneAnimations), -1);
  rb_define_method(SwigClassSceneManager.klass, "_renderVisibleObjects", VALUEFUNC(_wrap_SceneManager__renderVisibleObjects), -1);
  rb_define_method(SwigClassSceneManager.klass, "_renderScene", VALUEFUNC(_wrap_SceneManager__renderScene), -1);
  rb_define_method(SwigClassSceneManager.klass, "_queueSkiesForRendering", VALUEFUNC(_wrap_SceneManager__queueSkiesForRendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "_setDestinationRenderSystem", VALUEFUNC(_wrap_SceneManager__setDestinationRenderSystem), -1);
  rb_define_method(SwigClassSceneManager.klass, "setSkyPlane", VALUEFUNC(_wrap_SceneManager_setSkyPlane), -1);
  rb_define_method(SwigClassSceneManager.klass, "_setSkyPlane", VALUEFUNC(_wrap_SceneManager__setSkyPlane), -1);
  rb_define_method(SwigClassSceneManager.klass, "setSkyPlaneEnabled", VALUEFUNC(_wrap_SceneManager_setSkyPlaneEnabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "isSkyPlaneEnabled", VALUEFUNC(_wrap_SceneManager_isSkyPlaneEnabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSkyPlaneNode", VALUEFUNC(_wrap_SceneManager_getSkyPlaneNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSkyPlaneGenParameters", VALUEFUNC(_wrap_SceneManager_getSkyPlaneGenParameters), -1);
  rb_define_method(SwigClassSceneManager.klass, "setSkyBox", VALUEFUNC(_wrap_SceneManager_setSkyBox), -1);
  rb_define_method(SwigClassSceneManager.klass, "_setSkyBox", VALUEFUNC(_wrap_SceneManager__setSkyBox), -1);
  rb_define_method(SwigClassSceneManager.klass, "setSkyBoxEnabled", VALUEFUNC(_wrap_SceneManager_setSkyBoxEnabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "isSkyBoxEnabled", VALUEFUNC(_wrap_SceneManager_isSkyBoxEnabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSkyBoxNode", VALUEFUNC(_wrap_SceneManager_getSkyBoxNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSkyBoxGenParameters", VALUEFUNC(_wrap_SceneManager_getSkyBoxGenParameters), -1);
  rb_define_method(SwigClassSceneManager.klass, "setSkyDome", VALUEFUNC(_wrap_SceneManager_setSkyDome), -1);
  rb_define_method(SwigClassSceneManager.klass, "_setSkyDome", VALUEFUNC(_wrap_SceneManager__setSkyDome), -1);
  rb_define_method(SwigClassSceneManager.klass, "setSkyDomeEnabled", VALUEFUNC(_wrap_SceneManager_setSkyDomeEnabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "isSkyDomeEnabled", VALUEFUNC(_wrap_SceneManager_isSkyDomeEnabled), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSkyDomeNode", VALUEFUNC(_wrap_SceneManager_getSkyDomeNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSkyDomeGenParameters", VALUEFUNC(_wrap_SceneManager_getSkyDomeGenParameters), -1);
  rb_define_method(SwigClassSceneManager.klass, "setFog", VALUEFUNC(_wrap_SceneManager_setFog), -1);
  rb_define_method(SwigClassSceneManager.klass, "getFogMode", VALUEFUNC(_wrap_SceneManager_getFogMode), -1);
  rb_define_method(SwigClassSceneManager.klass, "getFogColour", VALUEFUNC(_wrap_SceneManager_getFogColour), -1);
  rb_define_method(SwigClassSceneManager.klass, "getFogStart", VALUEFUNC(_wrap_SceneManager_getFogStart), -1);
  rb_define_method(SwigClassSceneManager.klass, "getFogEnd", VALUEFUNC(_wrap_SceneManager_getFogEnd), -1);
  rb_define_method(SwigClassSceneManager.klass, "getFogDensity", VALUEFUNC(_wrap_SceneManager_getFogDensity), -1);
  rb_define_method(SwigClassSceneManager.klass, "createBillboardSet", VALUEFUNC(_wrap_SceneManager_createBillboardSet), -1);
  rb_define_method(SwigClassSceneManager.klass, "getBillboardSet", VALUEFUNC(_wrap_SceneManager_getBillboardSet), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasBillboardSet", VALUEFUNC(_wrap_SceneManager_hasBillboardSet), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyBillboardSet", VALUEFUNC(_wrap_SceneManager_destroyBillboardSet), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllBillboardSets", VALUEFUNC(_wrap_SceneManager_destroyAllBillboardSets), -1);
  rb_define_method(SwigClassSceneManager.klass, "setDisplaySceneNodes", VALUEFUNC(_wrap_SceneManager_setDisplaySceneNodes), -1);
  rb_define_method(SwigClassSceneManager.klass, "getDisplaySceneNodes", VALUEFUNC(_wrap_SceneManager_getDisplaySceneNodes), -1);
  rb_define_method(SwigClassSceneManager.klass, "createAnimation", VALUEFUNC(_wrap_SceneManager_createAnimation), -1);
  rb_define_method(SwigClassSceneManager.klass, "getAnimation", VALUEFUNC(_wrap_SceneManager_getAnimation), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasAnimation", VALUEFUNC(_wrap_SceneManager_hasAnimation), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAnimation", VALUEFUNC(_wrap_SceneManager_destroyAnimation), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllAnimations", VALUEFUNC(_wrap_SceneManager_destroyAllAnimations), -1);
  rb_define_method(SwigClassSceneManager.klass, "createAnimationState", VALUEFUNC(_wrap_SceneManager_createAnimationState), -1);
  rb_define_method(SwigClassSceneManager.klass, "getAnimationState", VALUEFUNC(_wrap_SceneManager_getAnimationState), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasAnimationState", VALUEFUNC(_wrap_SceneManager_hasAnimationState), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAnimationState", VALUEFUNC(_wrap_SceneManager_destroyAnimationState), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllAnimationStates", VALUEFUNC(_wrap_SceneManager_destroyAllAnimationStates), -1);
  rb_define_method(SwigClassSceneManager.klass, "manualRender", VALUEFUNC(_wrap_SceneManager_manualRender), -1);
  rb_define_method(SwigClassSceneManager.klass, "getRenderQueue", VALUEFUNC(_wrap_SceneManager_getRenderQueue), -1);
  rb_define_method(SwigClassSceneManager.klass, "addRenderQueueListener", VALUEFUNC(_wrap_SceneManager_addRenderQueueListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "removeRenderQueueListener", VALUEFUNC(_wrap_SceneManager_removeRenderQueueListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "addRenderObjectListener", VALUEFUNC(_wrap_SceneManager_addRenderObjectListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "removeRenderObjectListener", VALUEFUNC(_wrap_SceneManager_removeRenderObjectListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "addSpecialCaseRenderQueue", VALUEFUNC(_wrap_SceneManager_addSpecialCaseRenderQueue), -1);
  rb_define_method(SwigClassSceneManager.klass, "removeSpecialCaseRenderQueue", VALUEFUNC(_wrap_SceneManager_removeSpecialCaseRenderQueue), -1);
  rb_define_method(SwigClassSceneManager.klass, "clearSpecialCaseRenderQueues", VALUEFUNC(_wrap_SceneManager_clearSpecialCaseRenderQueues), -1);
  rb_define_method(SwigClassSceneManager.klass, "setSpecialCaseRenderQueueMode", VALUEFUNC(_wrap_SceneManager_setSpecialCaseRenderQueueMode), -1);
  rb_define_method(SwigClassSceneManager.klass, "getSpecialCaseRenderQueueMode", VALUEFUNC(_wrap_SceneManager_getSpecialCaseRenderQueueMode), -1);
  rb_define_method(SwigClassSceneManager.klass, "isRenderQueueToBeProcessed", VALUEFUNC(_wrap_SceneManager_isRenderQueueToBeProcessed), -1);
  rb_define_method(SwigClassSceneManager.klass, "setWorldGeometryRenderQueue", VALUEFUNC(_wrap_SceneManager_setWorldGeometryRenderQueue), -1);
  rb_define_method(SwigClassSceneManager.klass, "getWorldGeometryRenderQueue", VALUEFUNC(_wrap_SceneManager_getWorldGeometryRenderQueue), -1);
  rb_define_method(SwigClassSceneManager.klass, "showBoundingBoxes", VALUEFUNC(_wrap_SceneManager_showBoundingBoxes), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShowBoundingBoxes", VALUEFUNC(_wrap_SceneManager_getShowBoundingBoxes), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notifyAutotrackingSceneNode", VALUEFUNC(_wrap_SceneManager__notifyAutotrackingSceneNode), -1);
  rb_define_method(SwigClassSceneManager.klass, "createAABBQuery", VALUEFUNC(_wrap_SceneManager_createAABBQuery), -1);
  rb_define_method(SwigClassSceneManager.klass, "createSphereQuery", VALUEFUNC(_wrap_SceneManager_createSphereQuery), -1);
  rb_define_method(SwigClassSceneManager.klass, "createPlaneBoundedVolumeQuery", VALUEFUNC(_wrap_SceneManager_createPlaneBoundedVolumeQuery), -1);
  rb_define_method(SwigClassSceneManager.klass, "createRayQuery", VALUEFUNC(_wrap_SceneManager_createRayQuery), -1);
  rb_define_method(SwigClassSceneManager.klass, "createIntersectionQuery", VALUEFUNC(_wrap_SceneManager_createIntersectionQuery), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyQuery", VALUEFUNC(_wrap_SceneManager_destroyQuery), -1);
  rb_define_method(SwigClassSceneManager.klass, "getCameraIterator", VALUEFUNC(_wrap_SceneManager_getCameraIterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "getAnimationIterator", VALUEFUNC(_wrap_SceneManager_getAnimationIterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "getAnimationStateIterator", VALUEFUNC(_wrap_SceneManager_getAnimationStateIterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTechnique", VALUEFUNC(_wrap_SceneManager_setShadowTechnique), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowTechnique", VALUEFUNC(_wrap_SceneManager_getShadowTechnique), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShowDebugShadows", VALUEFUNC(_wrap_SceneManager_setShowDebugShadows), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShowDebugShadows", VALUEFUNC(_wrap_SceneManager_getShowDebugShadows), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowColour", VALUEFUNC(_wrap_SceneManager_setShadowColour), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowColour", VALUEFUNC(_wrap_SceneManager_getShadowColour), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowDirectionalLightExtrusionDistance", VALUEFUNC(_wrap_SceneManager_setShadowDirectionalLightExtrusionDistance), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowDirectionalLightExtrusionDistance", VALUEFUNC(_wrap_SceneManager_getShadowDirectionalLightExtrusionDistance), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowFarDistance", VALUEFUNC(_wrap_SceneManager_setShadowFarDistance), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowFarDistance", VALUEFUNC(_wrap_SceneManager_getShadowFarDistance), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowFarDistanceSquared", VALUEFUNC(_wrap_SceneManager_getShadowFarDistanceSquared), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowIndexBufferSize", VALUEFUNC(_wrap_SceneManager_setShadowIndexBufferSize), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowIndexBufferSize", VALUEFUNC(_wrap_SceneManager_getShadowIndexBufferSize), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureSize", VALUEFUNC(_wrap_SceneManager_setShadowTextureSize), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureConfig", VALUEFUNC(_wrap_SceneManager_setShadowTextureConfig), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowTextureConfigIterator", VALUEFUNC(_wrap_SceneManager_getShadowTextureConfigIterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTexturePixelFormat", VALUEFUNC(_wrap_SceneManager_setShadowTexturePixelFormat), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureFSAA", VALUEFUNC(_wrap_SceneManager_setShadowTextureFSAA), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureCount", VALUEFUNC(_wrap_SceneManager_setShadowTextureCount), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowTextureCount", VALUEFUNC(_wrap_SceneManager_getShadowTextureCount), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureCountPerLightType", VALUEFUNC(_wrap_SceneManager_setShadowTextureCountPerLightType), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowTextureCountPerLightType", VALUEFUNC(_wrap_SceneManager_getShadowTextureCountPerLightType), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureSettings", VALUEFUNC(_wrap_SceneManager_setShadowTextureSettings), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowTexture", VALUEFUNC(_wrap_SceneManager_getShadowTexture), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowDirLightTextureOffset", VALUEFUNC(_wrap_SceneManager_setShadowDirLightTextureOffset), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowDirLightTextureOffset", VALUEFUNC(_wrap_SceneManager_getShadowDirLightTextureOffset), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureFadeStart", VALUEFUNC(_wrap_SceneManager_setShadowTextureFadeStart), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureFadeEnd", VALUEFUNC(_wrap_SceneManager_setShadowTextureFadeEnd), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureSelfShadow", VALUEFUNC(_wrap_SceneManager_setShadowTextureSelfShadow), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowTextureSelfShadow", VALUEFUNC(_wrap_SceneManager_getShadowTextureSelfShadow), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureCasterMaterial", VALUEFUNC(_wrap_SceneManager_setShadowTextureCasterMaterial), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowTextureReceiverMaterial", VALUEFUNC(_wrap_SceneManager_setShadowTextureReceiverMaterial), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowCasterRenderBackFaces", VALUEFUNC(_wrap_SceneManager_setShadowCasterRenderBackFaces), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowCasterRenderBackFaces", VALUEFUNC(_wrap_SceneManager_getShadowCasterRenderBackFaces), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowCameraSetup", VALUEFUNC(_wrap_SceneManager_setShadowCameraSetup), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowCameraSetup", VALUEFUNC(_wrap_SceneManager_getShadowCameraSetup), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowUseInfiniteFarPlane", VALUEFUNC(_wrap_SceneManager_setShadowUseInfiniteFarPlane), -1);
  rb_define_method(SwigClassSceneManager.klass, "isShadowTechniqueStencilBased", VALUEFUNC(_wrap_SceneManager_isShadowTechniqueStencilBased), -1);
  rb_define_method(SwigClassSceneManager.klass, "isShadowTechniqueTextureBased", VALUEFUNC(_wrap_SceneManager_isShadowTechniqueTextureBased), -1);
  rb_define_method(SwigClassSceneManager.klass, "isShadowTechniqueModulative", VALUEFUNC(_wrap_SceneManager_isShadowTechniqueModulative), -1);
  rb_define_method(SwigClassSceneManager.klass, "isShadowTechniqueAdditive", VALUEFUNC(_wrap_SceneManager_isShadowTechniqueAdditive), -1);
  rb_define_method(SwigClassSceneManager.klass, "isShadowTechniqueIntegrated", VALUEFUNC(_wrap_SceneManager_isShadowTechniqueIntegrated), -1);
  rb_define_method(SwigClassSceneManager.klass, "isShadowTechniqueInUse", VALUEFUNC(_wrap_SceneManager_isShadowTechniqueInUse), -1);
  rb_define_method(SwigClassSceneManager.klass, "setShadowUseLightClipPlanes", VALUEFUNC(_wrap_SceneManager_setShadowUseLightClipPlanes), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowUseLightClipPlanes", VALUEFUNC(_wrap_SceneManager_getShadowUseLightClipPlanes), -1);
  rb_define_method(SwigClassSceneManager.klass, "_setActiveCompositorChain", VALUEFUNC(_wrap_SceneManager__setActiveCompositorChain), -1);
  rb_define_method(SwigClassSceneManager.klass, "setLateMaterialResolving", VALUEFUNC(_wrap_SceneManager_setLateMaterialResolving), -1);
  rb_define_method(SwigClassSceneManager.klass, "isLateMaterialResolving", VALUEFUNC(_wrap_SceneManager_isLateMaterialResolving), -1);
  rb_define_method(SwigClassSceneManager.klass, "_getActiveCompositorChain", VALUEFUNC(_wrap_SceneManager__getActiveCompositorChain), -1);
  rb_define_method(SwigClassSceneManager.klass, "addListener", VALUEFUNC(_wrap_SceneManager_addListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "removeListener", VALUEFUNC(_wrap_SceneManager_removeListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "createStaticGeometry", VALUEFUNC(_wrap_SceneManager_createStaticGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "getStaticGeometry", VALUEFUNC(_wrap_SceneManager_getStaticGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasStaticGeometry", VALUEFUNC(_wrap_SceneManager_hasStaticGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyStaticGeometry", VALUEFUNC(_wrap_SceneManager_destroyStaticGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllStaticGeometry", VALUEFUNC(_wrap_SceneManager_destroyAllStaticGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "createInstancedGeometry", VALUEFUNC(_wrap_SceneManager_createInstancedGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "getInstancedGeometry", VALUEFUNC(_wrap_SceneManager_getInstancedGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyInstancedGeometry", VALUEFUNC(_wrap_SceneManager_destroyInstancedGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllInstancedGeometry", VALUEFUNC(_wrap_SceneManager_destroyAllInstancedGeometry), -1);
  rb_define_method(SwigClassSceneManager.klass, "createInstanceManager", VALUEFUNC(_wrap_SceneManager_createInstanceManager), -1);
  rb_define_method(SwigClassSceneManager.klass, "getInstanceManager", VALUEFUNC(_wrap_SceneManager_getInstanceManager), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasInstanceManager", VALUEFUNC(_wrap_SceneManager_hasInstanceManager), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyInstanceManager", VALUEFUNC(_wrap_SceneManager_destroyInstanceManager), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllInstanceManagers", VALUEFUNC(_wrap_SceneManager_destroyAllInstanceManagers), -1);
  rb_define_method(SwigClassSceneManager.klass, "getNumInstancesPerBatch", VALUEFUNC(_wrap_SceneManager_getNumInstancesPerBatch), -1);
  rb_define_method(SwigClassSceneManager.klass, "createInstancedEntity", VALUEFUNC(_wrap_SceneManager_createInstancedEntity), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyInstancedEntity", VALUEFUNC(_wrap_SceneManager_destroyInstancedEntity), -1);
  rb_define_method(SwigClassSceneManager.klass, "_addDirtyInstanceManager", VALUEFUNC(_wrap_SceneManager__addDirtyInstanceManager), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyMovableObject", VALUEFUNC(_wrap_SceneManager_destroyMovableObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllMovableObjectsByType", VALUEFUNC(_wrap_SceneManager_destroyAllMovableObjectsByType), -1);
  rb_define_method(SwigClassSceneManager.klass, "destroyAllMovableObjects", VALUEFUNC(_wrap_SceneManager_destroyAllMovableObjects), -1);
  rb_define_method(SwigClassSceneManager.klass, "getMovableObject", VALUEFUNC(_wrap_SceneManager_getMovableObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "hasMovableObject", VALUEFUNC(_wrap_SceneManager_hasMovableObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "getMovableObjectIterator", VALUEFUNC(_wrap_SceneManager_getMovableObjectIterator), -1);
  rb_define_method(SwigClassSceneManager.klass, "injectMovableObject", VALUEFUNC(_wrap_SceneManager_injectMovableObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "extractMovableObject", VALUEFUNC(_wrap_SceneManager_extractMovableObject), -1);
  rb_define_method(SwigClassSceneManager.klass, "extractAllMovableObjectsByType", VALUEFUNC(_wrap_SceneManager_extractAllMovableObjectsByType), -1);
  rb_define_method(SwigClassSceneManager.klass, "setVisibilityMask", VALUEFUNC(_wrap_SceneManager_setVisibilityMask), -1);
  rb_define_method(SwigClassSceneManager.klass, "getVisibilityMask", VALUEFUNC(_wrap_SceneManager_getVisibilityMask), -1);
  rb_define_method(SwigClassSceneManager.klass, "_getCombinedVisibilityMask", VALUEFUNC(_wrap_SceneManager__getCombinedVisibilityMask), -1);
  rb_define_method(SwigClassSceneManager.klass, "setFindVisibleObjects", VALUEFUNC(_wrap_SceneManager_setFindVisibleObjects), -1);
  rb_define_method(SwigClassSceneManager.klass, "getFindVisibleObjects", VALUEFUNC(_wrap_SceneManager_getFindVisibleObjects), -1);
  rb_define_method(SwigClassSceneManager.klass, "setNormaliseNormalsOnScale", VALUEFUNC(_wrap_SceneManager_setNormaliseNormalsOnScale), -1);
  rb_define_method(SwigClassSceneManager.klass, "getNormaliseNormalsOnScale", VALUEFUNC(_wrap_SceneManager_getNormaliseNormalsOnScale), -1);
  rb_define_method(SwigClassSceneManager.klass, "setFlipCullingOnNegativeScale", VALUEFUNC(_wrap_SceneManager_setFlipCullingOnNegativeScale), -1);
  rb_define_method(SwigClassSceneManager.klass, "getFlipCullingOnNegativeScale", VALUEFUNC(_wrap_SceneManager_getFlipCullingOnNegativeScale), -1);
  rb_define_method(SwigClassSceneManager.klass, "_injectRenderWithPass", VALUEFUNC(_wrap_SceneManager__injectRenderWithPass), -1);
  rb_define_method(SwigClassSceneManager.klass, "_suppressRenderStateChanges", VALUEFUNC(_wrap_SceneManager__suppressRenderStateChanges), -1);
  rb_define_method(SwigClassSceneManager.klass, "_areRenderStateChangesSuppressed", VALUEFUNC(_wrap_SceneManager__areRenderStateChangesSuppressed), -1);
  rb_define_method(SwigClassSceneManager.klass, "_setPass", VALUEFUNC(_wrap_SceneManager__setPass), -1);
  rb_define_method(SwigClassSceneManager.klass, "_markGpuParamsDirty", VALUEFUNC(_wrap_SceneManager__markGpuParamsDirty), -1);
  rb_define_method(SwigClassSceneManager.klass, "_suppressShadows", VALUEFUNC(_wrap_SceneManager__suppressShadows), -1);
  rb_define_method(SwigClassSceneManager.klass, "_areShadowsSuppressed", VALUEFUNC(_wrap_SceneManager__areShadowsSuppressed), -1);
  rb_define_method(SwigClassSceneManager.klass, "_renderQueueGroupObjects", VALUEFUNC(_wrap_SceneManager__renderQueueGroupObjects), -1);
  rb_define_method(SwigClassSceneManager.klass, "setQueuedRenderableVisitor", VALUEFUNC(_wrap_SceneManager_setQueuedRenderableVisitor), -1);
  rb_define_method(SwigClassSceneManager.klass, "getQueuedRenderableVisitor", VALUEFUNC(_wrap_SceneManager_getQueuedRenderableVisitor), -1);
  rb_define_method(SwigClassSceneManager.klass, "getDestinationRenderSystem", VALUEFUNC(_wrap_SceneManager_getDestinationRenderSystem), -1);
  rb_define_method(SwigClassSceneManager.klass, "getCurrentViewport", VALUEFUNC(_wrap_SceneManager_getCurrentViewport), -1);
  rb_define_method(SwigClassSceneManager.klass, "getVisibleObjectsBoundsInfo", VALUEFUNC(_wrap_SceneManager_getVisibleObjectsBoundsInfo), -1);
  rb_define_method(SwigClassSceneManager.klass, "getShadowCasterBoundsInfo", VALUEFUNC(_wrap_SceneManager_getShadowCasterBoundsInfo), -1);
  rb_define_method(SwigClassSceneManager.klass, "setCameraRelativeRendering", VALUEFUNC(_wrap_SceneManager_setCameraRelativeRendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "getCameraRelativeRendering", VALUEFUNC(_wrap_SceneManager_getCameraRelativeRendering), -1);
  rb_define_method(SwigClassSceneManager.klass, "addLodListener", VALUEFUNC(_wrap_SceneManager_addLodListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "removeLodListener", VALUEFUNC(_wrap_SceneManager_removeLodListener), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notifyMovableObjectLodChanged", VALUEFUNC(_wrap_SceneManager__notifyMovableObjectLodChanged), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notifyEntityMeshLodChanged", VALUEFUNC(_wrap_SceneManager__notifyEntityMeshLodChanged), -1);
  rb_define_method(SwigClassSceneManager.klass, "_notifyEntityMaterialLodChanged", VALUEFUNC(_wrap_SceneManager__notifyEntityMaterialLodChanged), -1);
  rb_define_method(SwigClassSceneManager.klass, "_handleLodEvents", VALUEFUNC(_wrap_SceneManager__handleLodEvents), -1);
  rb_define_method(SwigClassSceneManager.klass, "createMovableObject", VALUEFUNC(_wrap_SceneManager_createMovableObject), -1);
  SwigClassSceneManager.mark = 0;
  SwigClassSceneManager.destroy = (void (*)(void *)) free_Ogre_SceneManager;
  SwigClassSceneManager.trackObjects = 0;
  
  SwigClassDefaultIntersectionSceneQuery.klass = rb_define_class_under(mOgre, "DefaultIntersectionSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__IntersectionSceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultIntersectionSceneQuery, (void *) &SwigClassDefaultIntersectionSceneQuery);
  rb_define_alloc_func(SwigClassDefaultIntersectionSceneQuery.klass, _wrap_DefaultIntersectionSceneQuery_allocate);
  rb_define_method(SwigClassDefaultIntersectionSceneQuery.klass, "initialize", VALUEFUNC(_wrap_new_DefaultIntersectionSceneQuery), -1);
  rb_define_method(SwigClassDefaultIntersectionSceneQuery.klass, "execute", VALUEFUNC(_wrap_DefaultIntersectionSceneQuery_execute), -1);
  SwigClassDefaultIntersectionSceneQuery.mark = 0;
  SwigClassDefaultIntersectionSceneQuery.destroy = (void (*)(void *)) free_Ogre_DefaultIntersectionSceneQuery;
  SwigClassDefaultIntersectionSceneQuery.trackObjects = 0;
  
  SwigClassDefaultRaySceneQuery.klass = rb_define_class_under(mOgre, "DefaultRaySceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__RaySceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultRaySceneQuery, (void *) &SwigClassDefaultRaySceneQuery);
  rb_define_alloc_func(SwigClassDefaultRaySceneQuery.klass, _wrap_DefaultRaySceneQuery_allocate);
  rb_define_method(SwigClassDefaultRaySceneQuery.klass, "initialize", VALUEFUNC(_wrap_new_DefaultRaySceneQuery), -1);
  rb_define_method(SwigClassDefaultRaySceneQuery.klass, "execute", VALUEFUNC(_wrap_DefaultRaySceneQuery_execute), -1);
  SwigClassDefaultRaySceneQuery.mark = 0;
  SwigClassDefaultRaySceneQuery.destroy = (void (*)(void *)) free_Ogre_DefaultRaySceneQuery;
  SwigClassDefaultRaySceneQuery.trackObjects = 0;
  
  SwigClassDefaultSphereSceneQuery.klass = rb_define_class_under(mOgre, "DefaultSphereSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__SphereSceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultSphereSceneQuery, (void *) &SwigClassDefaultSphereSceneQuery);
  rb_define_alloc_func(SwigClassDefaultSphereSceneQuery.klass, _wrap_DefaultSphereSceneQuery_allocate);
  rb_define_method(SwigClassDefaultSphereSceneQuery.klass, "initialize", VALUEFUNC(_wrap_new_DefaultSphereSceneQuery), -1);
  rb_define_method(SwigClassDefaultSphereSceneQuery.klass, "execute", VALUEFUNC(_wrap_DefaultSphereSceneQuery_execute), -1);
  SwigClassDefaultSphereSceneQuery.mark = 0;
  SwigClassDefaultSphereSceneQuery.destroy = (void (*)(void *)) free_Ogre_DefaultSphereSceneQuery;
  SwigClassDefaultSphereSceneQuery.trackObjects = 0;
  
  SwigClassDefaultPlaneBoundedVolumeListSceneQuery.klass = rb_define_class_under(mOgre, "DefaultPlaneBoundedVolumeListSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__PlaneBoundedVolumeListSceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultPlaneBoundedVolumeListSceneQuery, (void *) &SwigClassDefaultPlaneBoundedVolumeListSceneQuery);
  rb_define_alloc_func(SwigClassDefaultPlaneBoundedVolumeListSceneQuery.klass, _wrap_DefaultPlaneBoundedVolumeListSceneQuery_allocate);
  rb_define_method(SwigClassDefaultPlaneBoundedVolumeListSceneQuery.klass, "initialize", VALUEFUNC(_wrap_new_DefaultPlaneBoundedVolumeListSceneQuery), -1);
  rb_define_method(SwigClassDefaultPlaneBoundedVolumeListSceneQuery.klass, "execute", VALUEFUNC(_wrap_DefaultPlaneBoundedVolumeListSceneQuery_execute), -1);
  SwigClassDefaultPlaneBoundedVolumeListSceneQuery.mark = 0;
  SwigClassDefaultPlaneBoundedVolumeListSceneQuery.destroy = (void (*)(void *)) free_Ogre_DefaultPlaneBoundedVolumeListSceneQuery;
  SwigClassDefaultPlaneBoundedVolumeListSceneQuery.trackObjects = 0;
  
  SwigClassDefaultAxisAlignedBoxSceneQuery.klass = rb_define_class_under(mOgre, "DefaultAxisAlignedBoxSceneQuery", ((swig_class *) SWIGTYPE_p_Ogre__AxisAlignedBoxSceneQuery->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultAxisAlignedBoxSceneQuery, (void *) &SwigClassDefaultAxisAlignedBoxSceneQuery);
  rb_define_alloc_func(SwigClassDefaultAxisAlignedBoxSceneQuery.klass, _wrap_DefaultAxisAlignedBoxSceneQuery_allocate);
  rb_define_method(SwigClassDefaultAxisAlignedBoxSceneQuery.klass, "initialize", VALUEFUNC(_wrap_new_DefaultAxisAlignedBoxSceneQuery), -1);
  rb_define_method(SwigClassDefaultAxisAlignedBoxSceneQuery.klass, "execute", VALUEFUNC(_wrap_DefaultAxisAlignedBoxSceneQuery_execute), -1);
  SwigClassDefaultAxisAlignedBoxSceneQuery.mark = 0;
  SwigClassDefaultAxisAlignedBoxSceneQuery.destroy = (void (*)(void *)) free_Ogre_DefaultAxisAlignedBoxSceneQuery;
  SwigClassDefaultAxisAlignedBoxSceneQuery.trackObjects = 0;
  rb_define_const(mOgre, "ST_GENERIC", SWIG_From_int(static_cast< int >(Ogre::ST_GENERIC)));
  rb_define_const(mOgre, "ST_EXTERIOR_CLOSE", SWIG_From_int(static_cast< int >(Ogre::ST_EXTERIOR_CLOSE)));
  rb_define_const(mOgre, "ST_EXTERIOR_FAR", SWIG_From_int(static_cast< int >(Ogre::ST_EXTERIOR_FAR)));
  rb_define_const(mOgre, "ST_EXTERIOR_REAL_FAR", SWIG_From_int(static_cast< int >(Ogre::ST_EXTERIOR_REAL_FAR)));
  rb_define_const(mOgre, "ST_INTERIOR", SWIG_From_int(static_cast< int >(Ogre::ST_INTERIOR)));
  
  SwigClassSceneManagerMetaData.klass = rb_define_class_under(mOgre, "SceneManagerMetaData", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneManagerMetaData, (void *) &SwigClassSceneManagerMetaData);
  rb_define_alloc_func(SwigClassSceneManagerMetaData.klass, _wrap_SceneManagerMetaData_allocate);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "initialize", VALUEFUNC(_wrap_new_SceneManagerMetaData), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "typeName=", VALUEFUNC(_wrap_SceneManagerMetaData_typeName_set), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "typeName", VALUEFUNC(_wrap_SceneManagerMetaData_typeName_get), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "description=", VALUEFUNC(_wrap_SceneManagerMetaData_description_set), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "description", VALUEFUNC(_wrap_SceneManagerMetaData_description_get), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "sceneTypeMask=", VALUEFUNC(_wrap_SceneManagerMetaData_sceneTypeMask_set), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "sceneTypeMask", VALUEFUNC(_wrap_SceneManagerMetaData_sceneTypeMask_get), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "worldGeometrySupported=", VALUEFUNC(_wrap_SceneManagerMetaData_worldGeometrySupported_set), -1);
  rb_define_method(SwigClassSceneManagerMetaData.klass, "worldGeometrySupported", VALUEFUNC(_wrap_SceneManagerMetaData_worldGeometrySupported_get), -1);
  SwigClassSceneManagerMetaData.mark = 0;
  SwigClassSceneManagerMetaData.destroy = (void (*)(void *)) free_Ogre_SceneManagerMetaData;
  SwigClassSceneManagerMetaData.trackObjects = 0;
  
  SwigClassSceneManagerFactory.klass = rb_define_class_under(mOgre, "SceneManagerFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneManagerFactory, (void *) &SwigClassSceneManagerFactory);
  rb_undef_alloc_func(SwigClassSceneManagerFactory.klass);
  rb_define_method(SwigClassSceneManagerFactory.klass, "getMetaData", VALUEFUNC(_wrap_SceneManagerFactory_getMetaData), -1);
  rb_define_method(SwigClassSceneManagerFactory.klass, "createInstance", VALUEFUNC(_wrap_SceneManagerFactory_createInstance), -1);
  rb_define_method(SwigClassSceneManagerFactory.klass, "destroyInstance", VALUEFUNC(_wrap_SceneManagerFactory_destroyInstance), -1);
  SwigClassSceneManagerFactory.mark = 0;
  SwigClassSceneManagerFactory.destroy = (void (*)(void *)) free_Ogre_SceneManagerFactory;
  SwigClassSceneManagerFactory.trackObjects = 0;
  
  SwigClassRoot.klass = rb_define_class_under(mOgre, "Root", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Root, (void *) &SwigClassRoot);
  rb_define_alloc_func(SwigClassRoot.klass, _wrap_Root_allocate);
  rb_define_method(SwigClassRoot.klass, "initialize", VALUEFUNC(_wrap_new_Root), -1);
  rb_define_method(SwigClassRoot.klass, "saveConfig", VALUEFUNC(_wrap_Root_saveConfig), -1);
  rb_define_method(SwigClassRoot.klass, "restoreConfig", VALUEFUNC(_wrap_Root_restoreConfig), -1);
  rb_define_method(SwigClassRoot.klass, "showConfigDialog", VALUEFUNC(_wrap_Root_showConfigDialog), -1);
  rb_define_method(SwigClassRoot.klass, "addRenderSystem", VALUEFUNC(_wrap_Root_addRenderSystem), -1);
  rb_define_method(SwigClassRoot.klass, "getAvailableRenderers", VALUEFUNC(_wrap_Root_getAvailableRenderers), -1);
  rb_define_method(SwigClassRoot.klass, "getRenderSystemByName", VALUEFUNC(_wrap_Root_getRenderSystemByName), -1);
  rb_define_method(SwigClassRoot.klass, "setRenderSystem", VALUEFUNC(_wrap_Root_setRenderSystem), -1);
  rb_define_method(SwigClassRoot.klass, "getRenderSystem", VALUEFUNC(_wrap_Root_getRenderSystem), -1);
  rb_define_method(SwigClassRoot.klass, "initialise", VALUEFUNC(_wrap_Root_initialise), -1);
  rb_define_method(SwigClassRoot.klass, "isInitialised", VALUEFUNC(_wrap_Root_isInitialised), -1);
  rb_define_method(SwigClassRoot.klass, "useCustomRenderSystemCapabilities", VALUEFUNC(_wrap_Root_useCustomRenderSystemCapabilities), -1);
  rb_define_method(SwigClassRoot.klass, "getRemoveRenderQueueStructuresOnClear", VALUEFUNC(_wrap_Root_getRemoveRenderQueueStructuresOnClear), -1);
  rb_define_method(SwigClassRoot.klass, "setRemoveRenderQueueStructuresOnClear", VALUEFUNC(_wrap_Root_setRemoveRenderQueueStructuresOnClear), -1);
  rb_define_method(SwigClassRoot.klass, "addSceneManagerFactory", VALUEFUNC(_wrap_Root_addSceneManagerFactory), -1);
  rb_define_method(SwigClassRoot.klass, "removeSceneManagerFactory", VALUEFUNC(_wrap_Root_removeSceneManagerFactory), -1);
  rb_define_method(SwigClassRoot.klass, "getSceneManagerMetaData", VALUEFUNC(_wrap_Root_getSceneManagerMetaData), -1);
  rb_define_method(SwigClassRoot.klass, "getSceneManagerMetaDataIterator", VALUEFUNC(_wrap_Root_getSceneManagerMetaDataIterator), -1);
  rb_define_method(SwigClassRoot.klass, "createSceneManager", VALUEFUNC(_wrap_Root_createSceneManager), -1);
  rb_define_method(SwigClassRoot.klass, "destroySceneManager", VALUEFUNC(_wrap_Root_destroySceneManager), -1);
  rb_define_method(SwigClassRoot.klass, "getSceneManager", VALUEFUNC(_wrap_Root_getSceneManager), -1);
  rb_define_method(SwigClassRoot.klass, "hasSceneManager", VALUEFUNC(_wrap_Root_hasSceneManager), -1);
  rb_define_method(SwigClassRoot.klass, "getSceneManagerIterator", VALUEFUNC(_wrap_Root_getSceneManagerIterator), -1);
  rb_define_method(SwigClassRoot.klass, "getTextureManager", VALUEFUNC(_wrap_Root_getTextureManager), -1);
  rb_define_method(SwigClassRoot.klass, "getMeshManager", VALUEFUNC(_wrap_Root_getMeshManager), -1);
  rb_define_method(SwigClassRoot.klass, "getErrorDescription", VALUEFUNC(_wrap_Root_getErrorDescription), -1);
  rb_define_method(SwigClassRoot.klass, "addFrameListener", VALUEFUNC(_wrap_Root_addFrameListener), -1);
  rb_define_method(SwigClassRoot.klass, "removeFrameListener", VALUEFUNC(_wrap_Root_removeFrameListener), -1);
  rb_define_method(SwigClassRoot.klass, "queueEndRendering", VALUEFUNC(_wrap_Root_queueEndRendering), -1);
  rb_define_method(SwigClassRoot.klass, "startRendering", VALUEFUNC(_wrap_Root_startRendering), -1);
  rb_define_method(SwigClassRoot.klass, "renderOneFrame", VALUEFUNC(_wrap_Root_renderOneFrame), -1);
  rb_define_method(SwigClassRoot.klass, "shutdown", VALUEFUNC(_wrap_Root_shutdown), -1);
  rb_define_method(SwigClassRoot.klass, "addResourceLocation", VALUEFUNC(_wrap_Root_addResourceLocation), -1);
  rb_define_method(SwigClassRoot.klass, "removeResourceLocation", VALUEFUNC(_wrap_Root_removeResourceLocation), -1);
  rb_define_method(SwigClassRoot.klass, "createFileStream", VALUEFUNC(_wrap_Root_createFileStream), -1);
  rb_define_method(SwigClassRoot.klass, "openFileStream", VALUEFUNC(_wrap_Root_openFileStream), -1);
  rb_define_method(SwigClassRoot.klass, "convertColourValue", VALUEFUNC(_wrap_Root_convertColourValue), -1);
  rb_define_method(SwigClassRoot.klass, "getAutoCreatedWindow", VALUEFUNC(_wrap_Root_getAutoCreatedWindow), -1);
  rb_define_method(SwigClassRoot.klass, "createRenderWindow", VALUEFUNC(_wrap_Root_createRenderWindow), -1);
  rb_define_method(SwigClassRoot.klass, "createRenderWindows", VALUEFUNC(_wrap_Root_createRenderWindows), -1);
  rb_define_method(SwigClassRoot.klass, "detachRenderTarget", VALUEFUNC(_wrap_Root_detachRenderTarget), -1);
  rb_define_method(SwigClassRoot.klass, "destroyRenderTarget", VALUEFUNC(_wrap_Root_destroyRenderTarget), -1);
  rb_define_method(SwigClassRoot.klass, "getRenderTarget", VALUEFUNC(_wrap_Root_getRenderTarget), -1);
  rb_define_method(SwigClassRoot.klass, "loadPlugin", VALUEFUNC(_wrap_Root_loadPlugin), -1);
  rb_define_method(SwigClassRoot.klass, "unloadPlugin", VALUEFUNC(_wrap_Root_unloadPlugin), -1);
  rb_define_method(SwigClassRoot.klass, "installPlugin", VALUEFUNC(_wrap_Root_installPlugin), -1);
  rb_define_method(SwigClassRoot.klass, "uninstallPlugin", VALUEFUNC(_wrap_Root_uninstallPlugin), -1);
  rb_define_method(SwigClassRoot.klass, "getInstalledPlugins", VALUEFUNC(_wrap_Root_getInstalledPlugins), -1);
  rb_define_method(SwigClassRoot.klass, "getTimer", VALUEFUNC(_wrap_Root_getTimer), -1);
  rb_define_method(SwigClassRoot.klass, "_fireFrameStarted", VALUEFUNC(_wrap_Root__fireFrameStarted), -1);
  rb_define_method(SwigClassRoot.klass, "_fireFrameRenderingQueued", VALUEFUNC(_wrap_Root__fireFrameRenderingQueued), -1);
  rb_define_method(SwigClassRoot.klass, "_fireFrameEnded", VALUEFUNC(_wrap_Root__fireFrameEnded), -1);
  rb_define_method(SwigClassRoot.klass, "getNextFrameNumber", VALUEFUNC(_wrap_Root_getNextFrameNumber), -1);
  rb_define_method(SwigClassRoot.klass, "_getCurrentSceneManager", VALUEFUNC(_wrap_Root__getCurrentSceneManager), -1);
  rb_define_method(SwigClassRoot.klass, "_pushCurrentSceneManager", VALUEFUNC(_wrap_Root__pushCurrentSceneManager), -1);
  rb_define_method(SwigClassRoot.klass, "_popCurrentSceneManager", VALUEFUNC(_wrap_Root__popCurrentSceneManager), -1);
  rb_define_method(SwigClassRoot.klass, "_updateAllRenderTargets", VALUEFUNC(_wrap_Root__updateAllRenderTargets), -1);
  rb_define_method(SwigClassRoot.klass, "createRenderQueueInvocationSequence", VALUEFUNC(_wrap_Root_createRenderQueueInvocationSequence), -1);
  rb_define_method(SwigClassRoot.klass, "getRenderQueueInvocationSequence", VALUEFUNC(_wrap_Root_getRenderQueueInvocationSequence), -1);
  rb_define_method(SwigClassRoot.klass, "destroyRenderQueueInvocationSequence", VALUEFUNC(_wrap_Root_destroyRenderQueueInvocationSequence), -1);
  rb_define_method(SwigClassRoot.klass, "destroyAllRenderQueueInvocationSequences", VALUEFUNC(_wrap_Root_destroyAllRenderQueueInvocationSequences), -1);
  rb_define_singleton_method(SwigClassRoot.klass, "getSingleton", VALUEFUNC(_wrap_Root_getSingleton), -1);
  rb_define_singleton_method(SwigClassRoot.klass, "getSingletonPtr", VALUEFUNC(_wrap_Root_getSingletonPtr), -1);
  rb_define_method(SwigClassRoot.klass, "clearEventTimes", VALUEFUNC(_wrap_Root_clearEventTimes), -1);
  rb_define_method(SwigClassRoot.klass, "setFrameSmoothingPeriod", VALUEFUNC(_wrap_Root_setFrameSmoothingPeriod), -1);
  rb_define_method(SwigClassRoot.klass, "getFrameSmoothingPeriod", VALUEFUNC(_wrap_Root_getFrameSmoothingPeriod), -1);
  rb_define_method(SwigClassRoot.klass, "addMovableObjectFactory", VALUEFUNC(_wrap_Root_addMovableObjectFactory), -1);
  rb_define_method(SwigClassRoot.klass, "removeMovableObjectFactory", VALUEFUNC(_wrap_Root_removeMovableObjectFactory), -1);
  rb_define_method(SwigClassRoot.klass, "hasMovableObjectFactory", VALUEFUNC(_wrap_Root_hasMovableObjectFactory), -1);
  rb_define_method(SwigClassRoot.klass, "getMovableObjectFactory", VALUEFUNC(_wrap_Root_getMovableObjectFactory), -1);
  rb_define_method(SwigClassRoot.klass, "_allocateNextMovableObjectTypeFlag", VALUEFUNC(_wrap_Root__allocateNextMovableObjectTypeFlag), -1);
  rb_define_method(SwigClassRoot.klass, "getMovableObjectFactoryIterator", VALUEFUNC(_wrap_Root_getMovableObjectFactoryIterator), -1);
  rb_define_method(SwigClassRoot.klass, "getDisplayMonitorCount", VALUEFUNC(_wrap_Root_getDisplayMonitorCount), -1);
  rb_define_method(SwigClassRoot.klass, "getWorkQueue", VALUEFUNC(_wrap_Root_getWorkQueue), -1);
  rb_define_method(SwigClassRoot.klass, "setWorkQueue", VALUEFUNC(_wrap_Root_setWorkQueue), -1);
  rb_define_method(SwigClassRoot.klass, "setBlendIndicesGpuRedundant", VALUEFUNC(_wrap_Root_setBlendIndicesGpuRedundant), -1);
  rb_define_method(SwigClassRoot.klass, "isBlendIndicesGpuRedundant", VALUEFUNC(_wrap_Root_isBlendIndicesGpuRedundant), -1);
  rb_define_method(SwigClassRoot.klass, "setBlendWeightsGpuRedundant", VALUEFUNC(_wrap_Root_setBlendWeightsGpuRedundant), -1);
  rb_define_method(SwigClassRoot.klass, "isBlendWeightsGpuRedundant", VALUEFUNC(_wrap_Root_isBlendWeightsGpuRedundant), -1);
  rb_define_method(SwigClassRoot.klass, "setDefaultMinPixelSize", VALUEFUNC(_wrap_Root_setDefaultMinPixelSize), -1);
  rb_define_method(SwigClassRoot.klass, "getDefaultMinPixelSize", VALUEFUNC(_wrap_Root_getDefaultMinPixelSize), -1);
  rb_define_method(SwigClassRoot.klass, "getAvailableRendererArray", VALUEFUNC(_wrap_Root_getAvailableRendererArray), -1);
  rb_define_method(SwigClassRoot.klass, "destruct", VALUEFUNC(_wrap_Root_destruct), -1);
  SwigClassRoot.mark = 0;
  SwigClassRoot.destroy = (void (*)(void *)) debug_free_Root;
  SwigClassRoot.trackObjects = 0;
  
  SwigClassDefaultSceneManagerFactory.klass = rb_define_class_under(mOgre, "DefaultSceneManagerFactory", ((swig_class *) SWIGTYPE_p_Ogre__SceneManagerFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultSceneManagerFactory, (void *) &SwigClassDefaultSceneManagerFactory);
  rb_define_alloc_func(SwigClassDefaultSceneManagerFactory.klass, _wrap_DefaultSceneManagerFactory_allocate);
  rb_define_method(SwigClassDefaultSceneManagerFactory.klass, "initialize", VALUEFUNC(_wrap_new_DefaultSceneManagerFactory), -1);
  rb_define_singleton_method(SwigClassDefaultSceneManagerFactory.klass, "FACTORY_TYPE_NAME", VALUEFUNC(_wrap_DefaultSceneManagerFactory_FACTORY_TYPE_NAME_get), 0);
  rb_define_method(SwigClassDefaultSceneManagerFactory.klass, "createInstance", VALUEFUNC(_wrap_DefaultSceneManagerFactory_createInstance), -1);
  rb_define_method(SwigClassDefaultSceneManagerFactory.klass, "destroyInstance", VALUEFUNC(_wrap_DefaultSceneManagerFactory_destroyInstance), -1);
  SwigClassDefaultSceneManagerFactory.mark = 0;
  SwigClassDefaultSceneManagerFactory.destroy = (void (*)(void *)) free_Ogre_DefaultSceneManagerFactory;
  SwigClassDefaultSceneManagerFactory.trackObjects = 0;
  
  SwigClassDefaultSceneManager.klass = rb_define_class_under(mOgre, "DefaultSceneManager", ((swig_class *) SWIGTYPE_p_Ogre__SceneManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__DefaultSceneManager, (void *) &SwigClassDefaultSceneManager);
  rb_define_alloc_func(SwigClassDefaultSceneManager.klass, _wrap_DefaultSceneManager_allocate);
  rb_define_method(SwigClassDefaultSceneManager.klass, "initialize", VALUEFUNC(_wrap_new_DefaultSceneManager), -1);
  rb_define_method(SwigClassDefaultSceneManager.klass, "getTypeName", VALUEFUNC(_wrap_DefaultSceneManager_getTypeName), -1);
  SwigClassDefaultSceneManager.mark = 0;
  SwigClassDefaultSceneManager.destroy = (void (*)(void *)) free_Ogre_DefaultSceneManager;
  SwigClassDefaultSceneManager.trackObjects = 0;
  
  SwigClassSceneManagerEnumerator.klass = rb_define_class_under(mOgre, "SceneManagerEnumerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SceneManagerEnumerator, (void *) &SwigClassSceneManagerEnumerator);
  rb_define_alloc_func(SwigClassSceneManagerEnumerator.klass, _wrap_SceneManagerEnumerator_allocate);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "initialize", VALUEFUNC(_wrap_new_SceneManagerEnumerator), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "addFactory", VALUEFUNC(_wrap_SceneManagerEnumerator_addFactory), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "removeFactory", VALUEFUNC(_wrap_SceneManagerEnumerator_removeFactory), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "getMetaData", VALUEFUNC(_wrap_SceneManagerEnumerator_getMetaData), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "getMetaDataIterator", VALUEFUNC(_wrap_SceneManagerEnumerator_getMetaDataIterator), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "createSceneManager", VALUEFUNC(_wrap_SceneManagerEnumerator_createSceneManager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "destroySceneManager", VALUEFUNC(_wrap_SceneManagerEnumerator_destroySceneManager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "getSceneManager", VALUEFUNC(_wrap_SceneManagerEnumerator_getSceneManager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "hasSceneManager", VALUEFUNC(_wrap_SceneManagerEnumerator_hasSceneManager), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "getSceneManagerIterator", VALUEFUNC(_wrap_SceneManagerEnumerator_getSceneManagerIterator), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "setRenderSystem", VALUEFUNC(_wrap_SceneManagerEnumerator_setRenderSystem), -1);
  rb_define_method(SwigClassSceneManagerEnumerator.klass, "shutdownAll", VALUEFUNC(_wrap_SceneManagerEnumerator_shutdownAll), -1);
  rb_define_singleton_method(SwigClassSceneManagerEnumerator.klass, "getSingleton", VALUEFUNC(_wrap_SceneManagerEnumerator_getSingleton), -1);
  rb_define_singleton_method(SwigClassSceneManagerEnumerator.klass, "getSingletonPtr", VALUEFUNC(_wrap_SceneManagerEnumerator_getSingletonPtr), -1);
  SwigClassSceneManagerEnumerator.mark = 0;
  SwigClassSceneManagerEnumerator.destroy = (void (*)(void *)) free_Ogre_SceneManagerEnumerator;
  SwigClassSceneManagerEnumerator.trackObjects = 0;
  rb_define_const(mOgre, "TID_LBRACKET", SWIG_From_int(static_cast< int >(Ogre::TID_LBRACKET)));
  rb_define_const(mOgre, "TID_RBRACKET", SWIG_From_int(static_cast< int >(Ogre::TID_RBRACKET)));
  rb_define_const(mOgre, "TID_COLON", SWIG_From_int(static_cast< int >(Ogre::TID_COLON)));
  rb_define_const(mOgre, "TID_VARIABLE", SWIG_From_int(static_cast< int >(Ogre::TID_VARIABLE)));
  rb_define_const(mOgre, "TID_WORD", SWIG_From_int(static_cast< int >(Ogre::TID_WORD)));
  rb_define_const(mOgre, "TID_QUOTE", SWIG_From_int(static_cast< int >(Ogre::TID_QUOTE)));
  rb_define_const(mOgre, "TID_NEWLINE", SWIG_From_int(static_cast< int >(Ogre::TID_NEWLINE)));
  rb_define_const(mOgre, "TID_UNKNOWN", SWIG_From_int(static_cast< int >(Ogre::TID_UNKNOWN)));
  rb_define_const(mOgre, "TID_END", SWIG_From_int(static_cast< int >(Ogre::TID_END)));
  
  SwigClassScriptToken.klass = rb_define_class_under(mOgre, "ScriptToken", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptToken, (void *) &SwigClassScriptToken);
  rb_define_alloc_func(SwigClassScriptToken.klass, _wrap_ScriptToken_allocate);
  rb_define_method(SwigClassScriptToken.klass, "initialize", VALUEFUNC(_wrap_new_ScriptToken), -1);
  rb_define_method(SwigClassScriptToken.klass, "lexeme=", VALUEFUNC(_wrap_ScriptToken_lexeme_set), -1);
  rb_define_method(SwigClassScriptToken.klass, "lexeme", VALUEFUNC(_wrap_ScriptToken_lexeme_get), -1);
  rb_define_method(SwigClassScriptToken.klass, "file=", VALUEFUNC(_wrap_ScriptToken_file_set), -1);
  rb_define_method(SwigClassScriptToken.klass, "file", VALUEFUNC(_wrap_ScriptToken_file_get), -1);
  rb_define_method(SwigClassScriptToken.klass, "type=", VALUEFUNC(_wrap_ScriptToken_type_set), -1);
  rb_define_method(SwigClassScriptToken.klass, "type", VALUEFUNC(_wrap_ScriptToken_type_get), -1);
  rb_define_method(SwigClassScriptToken.klass, "line=", VALUEFUNC(_wrap_ScriptToken_line_set), -1);
  rb_define_method(SwigClassScriptToken.klass, "line", VALUEFUNC(_wrap_ScriptToken_line_get), -1);
  SwigClassScriptToken.mark = 0;
  SwigClassScriptToken.destroy = (void (*)(void *)) free_Ogre_ScriptToken;
  SwigClassScriptToken.trackObjects = 0;
  
  SwigClassScriptLexer.klass = rb_define_class_under(mOgre, "ScriptLexer", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptLexer, (void *) &SwigClassScriptLexer);
  rb_define_alloc_func(SwigClassScriptLexer.klass, _wrap_ScriptLexer_allocate);
  rb_define_method(SwigClassScriptLexer.klass, "initialize", VALUEFUNC(_wrap_new_ScriptLexer), -1);
  rb_define_method(SwigClassScriptLexer.klass, "tokenize", VALUEFUNC(_wrap_ScriptLexer_tokenize), -1);
  SwigClassScriptLexer.mark = 0;
  SwigClassScriptLexer.destroy = (void (*)(void *)) free_Ogre_ScriptLexer;
  SwigClassScriptLexer.trackObjects = 0;
  
  SwigClassScriptParser.klass = rb_define_class_under(mOgre, "ScriptParser", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptParser, (void *) &SwigClassScriptParser);
  rb_define_alloc_func(SwigClassScriptParser.klass, _wrap_ScriptParser_allocate);
  rb_define_method(SwigClassScriptParser.klass, "initialize", VALUEFUNC(_wrap_new_ScriptParser), -1);
  rb_define_method(SwigClassScriptParser.klass, "parse", VALUEFUNC(_wrap_ScriptParser_parse), -1);
  rb_define_method(SwigClassScriptParser.klass, "parseChunk", VALUEFUNC(_wrap_ScriptParser_parseChunk), -1);
  SwigClassScriptParser.mark = 0;
  SwigClassScriptParser.destroy = (void (*)(void *)) free_Ogre_ScriptParser;
  SwigClassScriptParser.trackObjects = 0;
  
  SwigClassScriptTranslator.klass = rb_define_class_under(mOgre, "ScriptTranslator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptTranslator, (void *) &SwigClassScriptTranslator);
  rb_undef_alloc_func(SwigClassScriptTranslator.klass);
  rb_define_method(SwigClassScriptTranslator.klass, "translate", VALUEFUNC(_wrap_ScriptTranslator_translate), -1);
  SwigClassScriptTranslator.mark = 0;
  SwigClassScriptTranslator.trackObjects = 0;
  
  SwigClassScriptTranslatorManager.klass = rb_define_class_under(mOgre, "ScriptTranslatorManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ScriptTranslatorManager, (void *) &SwigClassScriptTranslatorManager);
  rb_undef_alloc_func(SwigClassScriptTranslatorManager.klass);
  rb_define_method(SwigClassScriptTranslatorManager.klass, "getNumTranslators", VALUEFUNC(_wrap_ScriptTranslatorManager_getNumTranslators), -1);
  rb_define_method(SwigClassScriptTranslatorManager.klass, "getTranslator", VALUEFUNC(_wrap_ScriptTranslatorManager_getTranslator), -1);
  SwigClassScriptTranslatorManager.mark = 0;
  SwigClassScriptTranslatorManager.destroy = (void (*)(void *)) free_Ogre_ScriptTranslatorManager;
  SwigClassScriptTranslatorManager.trackObjects = 0;
  
  SwigClassMaterialTranslator.klass = rb_define_class_under(mOgre, "MaterialTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__MaterialTranslator, (void *) &SwigClassMaterialTranslator);
  rb_define_alloc_func(SwigClassMaterialTranslator.klass, _wrap_MaterialTranslator_allocate);
  rb_define_method(SwigClassMaterialTranslator.klass, "initialize", VALUEFUNC(_wrap_new_MaterialTranslator), -1);
  rb_define_method(SwigClassMaterialTranslator.klass, "translate", VALUEFUNC(_wrap_MaterialTranslator_translate), -1);
  SwigClassMaterialTranslator.mark = 0;
  SwigClassMaterialTranslator.destroy = (void (*)(void *)) free_Ogre_MaterialTranslator;
  SwigClassMaterialTranslator.trackObjects = 0;
  
  SwigClassTechniqueTranslator.klass = rb_define_class_under(mOgre, "TechniqueTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TechniqueTranslator, (void *) &SwigClassTechniqueTranslator);
  rb_define_alloc_func(SwigClassTechniqueTranslator.klass, _wrap_TechniqueTranslator_allocate);
  rb_define_method(SwigClassTechniqueTranslator.klass, "initialize", VALUEFUNC(_wrap_new_TechniqueTranslator), -1);
  rb_define_method(SwigClassTechniqueTranslator.klass, "translate", VALUEFUNC(_wrap_TechniqueTranslator_translate), -1);
  SwigClassTechniqueTranslator.mark = 0;
  SwigClassTechniqueTranslator.destroy = (void (*)(void *)) free_Ogre_TechniqueTranslator;
  SwigClassTechniqueTranslator.trackObjects = 0;
  
  SwigClassPassTranslator.klass = rb_define_class_under(mOgre, "PassTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PassTranslator, (void *) &SwigClassPassTranslator);
  rb_define_alloc_func(SwigClassPassTranslator.klass, _wrap_PassTranslator_allocate);
  rb_define_method(SwigClassPassTranslator.klass, "initialize", VALUEFUNC(_wrap_new_PassTranslator), -1);
  rb_define_method(SwigClassPassTranslator.klass, "translate", VALUEFUNC(_wrap_PassTranslator_translate), -1);
  SwigClassPassTranslator.mark = 0;
  SwigClassPassTranslator.destroy = (void (*)(void *)) free_Ogre_PassTranslator;
  SwigClassPassTranslator.trackObjects = 0;
  
  SwigClassTextureUnitTranslator.klass = rb_define_class_under(mOgre, "TextureUnitTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TextureUnitTranslator, (void *) &SwigClassTextureUnitTranslator);
  rb_define_alloc_func(SwigClassTextureUnitTranslator.klass, _wrap_TextureUnitTranslator_allocate);
  rb_define_method(SwigClassTextureUnitTranslator.klass, "initialize", VALUEFUNC(_wrap_new_TextureUnitTranslator), -1);
  rb_define_method(SwigClassTextureUnitTranslator.klass, "translate", VALUEFUNC(_wrap_TextureUnitTranslator_translate), -1);
  SwigClassTextureUnitTranslator.mark = 0;
  SwigClassTextureUnitTranslator.destroy = (void (*)(void *)) free_Ogre_TextureUnitTranslator;
  SwigClassTextureUnitTranslator.trackObjects = 0;
  
  SwigClassTextureSourceTranslator.klass = rb_define_class_under(mOgre, "TextureSourceTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TextureSourceTranslator, (void *) &SwigClassTextureSourceTranslator);
  rb_define_alloc_func(SwigClassTextureSourceTranslator.klass, _wrap_TextureSourceTranslator_allocate);
  rb_define_method(SwigClassTextureSourceTranslator.klass, "initialize", VALUEFUNC(_wrap_new_TextureSourceTranslator), -1);
  rb_define_method(SwigClassTextureSourceTranslator.klass, "translate", VALUEFUNC(_wrap_TextureSourceTranslator_translate), -1);
  SwigClassTextureSourceTranslator.mark = 0;
  SwigClassTextureSourceTranslator.destroy = (void (*)(void *)) free_Ogre_TextureSourceTranslator;
  SwigClassTextureSourceTranslator.trackObjects = 0;
  
  SwigClassGpuProgramTranslator.klass = rb_define_class_under(mOgre, "GpuProgramTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__GpuProgramTranslator, (void *) &SwigClassGpuProgramTranslator);
  rb_define_alloc_func(SwigClassGpuProgramTranslator.klass, _wrap_GpuProgramTranslator_allocate);
  rb_define_method(SwigClassGpuProgramTranslator.klass, "initialize", VALUEFUNC(_wrap_new_GpuProgramTranslator), -1);
  rb_define_method(SwigClassGpuProgramTranslator.klass, "translate", VALUEFUNC(_wrap_GpuProgramTranslator_translate), -1);
  rb_define_singleton_method(SwigClassGpuProgramTranslator.klass, "translateProgramParameters", VALUEFUNC(_wrap_GpuProgramTranslator_translateProgramParameters), -1);
  SwigClassGpuProgramTranslator.mark = 0;
  SwigClassGpuProgramTranslator.destroy = (void (*)(void *)) free_Ogre_GpuProgramTranslator;
  SwigClassGpuProgramTranslator.trackObjects = 0;
  
  SwigClassSharedParamsTranslator.klass = rb_define_class_under(mOgre, "SharedParamsTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SharedParamsTranslator, (void *) &SwigClassSharedParamsTranslator);
  rb_define_alloc_func(SwigClassSharedParamsTranslator.klass, _wrap_SharedParamsTranslator_allocate);
  rb_define_method(SwigClassSharedParamsTranslator.klass, "initialize", VALUEFUNC(_wrap_new_SharedParamsTranslator), -1);
  rb_define_method(SwigClassSharedParamsTranslator.klass, "translate", VALUEFUNC(_wrap_SharedParamsTranslator_translate), -1);
  SwigClassSharedParamsTranslator.mark = 0;
  SwigClassSharedParamsTranslator.destroy = (void (*)(void *)) free_Ogre_SharedParamsTranslator;
  SwigClassSharedParamsTranslator.trackObjects = 0;
  
  SwigClassParticleSystemTranslator.klass = rb_define_class_under(mOgre, "ParticleSystemTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleSystemTranslator, (void *) &SwigClassParticleSystemTranslator);
  rb_define_alloc_func(SwigClassParticleSystemTranslator.klass, _wrap_ParticleSystemTranslator_allocate);
  rb_define_method(SwigClassParticleSystemTranslator.klass, "initialize", VALUEFUNC(_wrap_new_ParticleSystemTranslator), -1);
  rb_define_method(SwigClassParticleSystemTranslator.klass, "translate", VALUEFUNC(_wrap_ParticleSystemTranslator_translate), -1);
  SwigClassParticleSystemTranslator.mark = 0;
  SwigClassParticleSystemTranslator.destroy = (void (*)(void *)) free_Ogre_ParticleSystemTranslator;
  SwigClassParticleSystemTranslator.trackObjects = 0;
  
  SwigClassParticleEmitterTranslator.klass = rb_define_class_under(mOgre, "ParticleEmitterTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleEmitterTranslator, (void *) &SwigClassParticleEmitterTranslator);
  rb_define_alloc_func(SwigClassParticleEmitterTranslator.klass, _wrap_ParticleEmitterTranslator_allocate);
  rb_define_method(SwigClassParticleEmitterTranslator.klass, "initialize", VALUEFUNC(_wrap_new_ParticleEmitterTranslator), -1);
  rb_define_method(SwigClassParticleEmitterTranslator.klass, "translate", VALUEFUNC(_wrap_ParticleEmitterTranslator_translate), -1);
  SwigClassParticleEmitterTranslator.mark = 0;
  SwigClassParticleEmitterTranslator.destroy = (void (*)(void *)) free_Ogre_ParticleEmitterTranslator;
  SwigClassParticleEmitterTranslator.trackObjects = 0;
  
  SwigClassParticleAffectorTranslator.klass = rb_define_class_under(mOgre, "ParticleAffectorTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ParticleAffectorTranslator, (void *) &SwigClassParticleAffectorTranslator);
  rb_define_alloc_func(SwigClassParticleAffectorTranslator.klass, _wrap_ParticleAffectorTranslator_allocate);
  rb_define_method(SwigClassParticleAffectorTranslator.klass, "initialize", VALUEFUNC(_wrap_new_ParticleAffectorTranslator), -1);
  rb_define_method(SwigClassParticleAffectorTranslator.klass, "translate", VALUEFUNC(_wrap_ParticleAffectorTranslator_translate), -1);
  SwigClassParticleAffectorTranslator.mark = 0;
  SwigClassParticleAffectorTranslator.destroy = (void (*)(void *)) free_Ogre_ParticleAffectorTranslator;
  SwigClassParticleAffectorTranslator.trackObjects = 0;
  
  SwigClassCompositorTranslator.klass = rb_define_class_under(mOgre, "CompositorTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositorTranslator, (void *) &SwigClassCompositorTranslator);
  rb_define_alloc_func(SwigClassCompositorTranslator.klass, _wrap_CompositorTranslator_allocate);
  rb_define_method(SwigClassCompositorTranslator.klass, "initialize", VALUEFUNC(_wrap_new_CompositorTranslator), -1);
  rb_define_method(SwigClassCompositorTranslator.klass, "translate", VALUEFUNC(_wrap_CompositorTranslator_translate), -1);
  SwigClassCompositorTranslator.mark = 0;
  SwigClassCompositorTranslator.destroy = (void (*)(void *)) free_Ogre_CompositorTranslator;
  SwigClassCompositorTranslator.trackObjects = 0;
  
  SwigClassCompositionTechniqueTranslator.klass = rb_define_class_under(mOgre, "CompositionTechniqueTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositionTechniqueTranslator, (void *) &SwigClassCompositionTechniqueTranslator);
  rb_define_alloc_func(SwigClassCompositionTechniqueTranslator.klass, _wrap_CompositionTechniqueTranslator_allocate);
  rb_define_method(SwigClassCompositionTechniqueTranslator.klass, "initialize", VALUEFUNC(_wrap_new_CompositionTechniqueTranslator), -1);
  rb_define_method(SwigClassCompositionTechniqueTranslator.klass, "translate", VALUEFUNC(_wrap_CompositionTechniqueTranslator_translate), -1);
  SwigClassCompositionTechniqueTranslator.mark = 0;
  SwigClassCompositionTechniqueTranslator.destroy = (void (*)(void *)) free_Ogre_CompositionTechniqueTranslator;
  SwigClassCompositionTechniqueTranslator.trackObjects = 0;
  
  SwigClassCompositionTargetPassTranslator.klass = rb_define_class_under(mOgre, "CompositionTargetPassTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositionTargetPassTranslator, (void *) &SwigClassCompositionTargetPassTranslator);
  rb_define_alloc_func(SwigClassCompositionTargetPassTranslator.klass, _wrap_CompositionTargetPassTranslator_allocate);
  rb_define_method(SwigClassCompositionTargetPassTranslator.klass, "initialize", VALUEFUNC(_wrap_new_CompositionTargetPassTranslator), -1);
  rb_define_method(SwigClassCompositionTargetPassTranslator.klass, "translate", VALUEFUNC(_wrap_CompositionTargetPassTranslator_translate), -1);
  SwigClassCompositionTargetPassTranslator.mark = 0;
  SwigClassCompositionTargetPassTranslator.destroy = (void (*)(void *)) free_Ogre_CompositionTargetPassTranslator;
  SwigClassCompositionTargetPassTranslator.trackObjects = 0;
  
  SwigClassCompositionPassTranslator.klass = rb_define_class_under(mOgre, "CompositionPassTranslator", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__CompositionPassTranslator, (void *) &SwigClassCompositionPassTranslator);
  rb_define_alloc_func(SwigClassCompositionPassTranslator.klass, _wrap_CompositionPassTranslator_allocate);
  rb_define_method(SwigClassCompositionPassTranslator.klass, "initialize", VALUEFUNC(_wrap_new_CompositionPassTranslator), -1);
  rb_define_method(SwigClassCompositionPassTranslator.klass, "translate", VALUEFUNC(_wrap_CompositionPassTranslator_translate), -1);
  SwigClassCompositionPassTranslator.mark = 0;
  SwigClassCompositionPassTranslator.destroy = (void (*)(void *)) free_Ogre_CompositionPassTranslator;
  SwigClassCompositionPassTranslator.trackObjects = 0;
  
  SwigClassBuiltinScriptTranslatorManager.klass = rb_define_class_under(mOgre, "BuiltinScriptTranslatorManager", ((swig_class *) SWIGTYPE_p_Ogre__ScriptTranslatorManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__BuiltinScriptTranslatorManager, (void *) &SwigClassBuiltinScriptTranslatorManager);
  rb_define_alloc_func(SwigClassBuiltinScriptTranslatorManager.klass, _wrap_BuiltinScriptTranslatorManager_allocate);
  rb_define_method(SwigClassBuiltinScriptTranslatorManager.klass, "initialize", VALUEFUNC(_wrap_new_BuiltinScriptTranslatorManager), -1);
  rb_define_method(SwigClassBuiltinScriptTranslatorManager.klass, "getNumTranslators", VALUEFUNC(_wrap_BuiltinScriptTranslatorManager_getNumTranslators), -1);
  rb_define_method(SwigClassBuiltinScriptTranslatorManager.klass, "getTranslator", VALUEFUNC(_wrap_BuiltinScriptTranslatorManager_getTranslator), -1);
  SwigClassBuiltinScriptTranslatorManager.mark = 0;
  SwigClassBuiltinScriptTranslatorManager.destroy = (void (*)(void *)) free_Ogre_BuiltinScriptTranslatorManager;
  SwigClassBuiltinScriptTranslatorManager.trackObjects = 0;
  
  SwigClassFocusedShadowCameraSetup.klass = rb_define_class_under(mOgre, "FocusedShadowCameraSetup", ((swig_class *) SWIGTYPE_p_Ogre__ShadowCameraSetup->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__FocusedShadowCameraSetup, (void *) &SwigClassFocusedShadowCameraSetup);
  rb_define_alloc_func(SwigClassFocusedShadowCameraSetup.klass, _wrap_FocusedShadowCameraSetup_allocate);
  rb_define_method(SwigClassFocusedShadowCameraSetup.klass, "initialize", VALUEFUNC(_wrap_new_FocusedShadowCameraSetup), -1);
  rb_define_method(SwigClassFocusedShadowCameraSetup.klass, "getShadowCamera", VALUEFUNC(_wrap_FocusedShadowCameraSetup_getShadowCamera), -1);
  rb_define_method(SwigClassFocusedShadowCameraSetup.klass, "setUseAggressiveFocusRegion", VALUEFUNC(_wrap_FocusedShadowCameraSetup_setUseAggressiveFocusRegion), -1);
  rb_define_method(SwigClassFocusedShadowCameraSetup.klass, "getUseAggressiveFocusRegion", VALUEFUNC(_wrap_FocusedShadowCameraSetup_getUseAggressiveFocusRegion), -1);
  SwigClassFocusedShadowCameraSetup.mark = 0;
  SwigClassFocusedShadowCameraSetup.destroy = (void (*)(void *)) free_Ogre_FocusedShadowCameraSetup;
  SwigClassFocusedShadowCameraSetup.trackObjects = 0;
  
  SwigClassLiSPSMShadowCameraSetup.klass = rb_define_class_under(mOgre, "LiSPSMShadowCameraSetup", ((swig_class *) SWIGTYPE_p_Ogre__FocusedShadowCameraSetup->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__LiSPSMShadowCameraSetup, (void *) &SwigClassLiSPSMShadowCameraSetup);
  rb_define_alloc_func(SwigClassLiSPSMShadowCameraSetup.klass, _wrap_LiSPSMShadowCameraSetup_allocate);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "initialize", VALUEFUNC(_wrap_new_LiSPSMShadowCameraSetup), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "getShadowCamera", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_getShadowCamera), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "setOptimalAdjustFactor", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_setOptimalAdjustFactor), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "getOptimalAdjustFactor", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_getOptimalAdjustFactor), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "setUseSimpleOptimalAdjust", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_setUseSimpleOptimalAdjust), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "getUseSimpleOptimalAdjust", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_getUseSimpleOptimalAdjust), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "setCameraLightDirectionThreshold", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_setCameraLightDirectionThreshold), -1);
  rb_define_method(SwigClassLiSPSMShadowCameraSetup.klass, "getCameraLightDirectionThreshold", VALUEFUNC(_wrap_LiSPSMShadowCameraSetup_getCameraLightDirectionThreshold), -1);
  SwigClassLiSPSMShadowCameraSetup.mark = 0;
  SwigClassLiSPSMShadowCameraSetup.destroy = (void (*)(void *)) free_Ogre_LiSPSMShadowCameraSetup;
  SwigClassLiSPSMShadowCameraSetup.trackObjects = 0;
  
  SwigClassPSSMShadowCameraSetup.klass = rb_define_class_under(mOgre, "PSSMShadowCameraSetup", ((swig_class *) SWIGTYPE_p_Ogre__LiSPSMShadowCameraSetup->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PSSMShadowCameraSetup, (void *) &SwigClassPSSMShadowCameraSetup);
  rb_define_alloc_func(SwigClassPSSMShadowCameraSetup.klass, _wrap_PSSMShadowCameraSetup_allocate);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "initialize", VALUEFUNC(_wrap_new_PSSMShadowCameraSetup), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "calculateSplitPoints", VALUEFUNC(_wrap_PSSMShadowCameraSetup_calculateSplitPoints), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "setSplitPoints", VALUEFUNC(_wrap_PSSMShadowCameraSetup_setSplitPoints), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "setOptimalAdjustFactor", VALUEFUNC(_wrap_PSSMShadowCameraSetup_setOptimalAdjustFactor), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "setSplitPadding", VALUEFUNC(_wrap_PSSMShadowCameraSetup_setSplitPadding), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "getSplitPadding", VALUEFUNC(_wrap_PSSMShadowCameraSetup_getSplitPadding), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "getSplitCount", VALUEFUNC(_wrap_PSSMShadowCameraSetup_getSplitCount), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "getShadowCamera", VALUEFUNC(_wrap_PSSMShadowCameraSetup_getShadowCamera), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "getSplitPoints", VALUEFUNC(_wrap_PSSMShadowCameraSetup_getSplitPoints), -1);
  rb_define_method(SwigClassPSSMShadowCameraSetup.klass, "getOptimalAdjustFactor", VALUEFUNC(_wrap_PSSMShadowCameraSetup_getOptimalAdjustFactor), -1);
  SwigClassPSSMShadowCameraSetup.mark = 0;
  SwigClassPSSMShadowCameraSetup.destroy = (void (*)(void *)) free_Ogre_PSSMShadowCameraSetup;
  SwigClassPSSMShadowCameraSetup.trackObjects = 0;
  
  SwigClassPlaneOptimalShadowCameraSetup.klass = rb_define_class_under(mOgre, "PlaneOptimalShadowCameraSetup", ((swig_class *) SWIGTYPE_p_Ogre__ShadowCameraSetup->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PlaneOptimalShadowCameraSetup, (void *) &SwigClassPlaneOptimalShadowCameraSetup);
  rb_define_alloc_func(SwigClassPlaneOptimalShadowCameraSetup.klass, _wrap_PlaneOptimalShadowCameraSetup_allocate);
  rb_define_method(SwigClassPlaneOptimalShadowCameraSetup.klass, "initialize", VALUEFUNC(_wrap_new_PlaneOptimalShadowCameraSetup), -1);
  rb_define_method(SwigClassPlaneOptimalShadowCameraSetup.klass, "getShadowCamera", VALUEFUNC(_wrap_PlaneOptimalShadowCameraSetup_getShadowCamera), -1);
  SwigClassPlaneOptimalShadowCameraSetup.mark = 0;
  SwigClassPlaneOptimalShadowCameraSetup.destroy = (void (*)(void *)) free_Ogre_PlaneOptimalShadowCameraSetup;
  SwigClassPlaneOptimalShadowCameraSetup.trackObjects = 0;
  rb_define_const(mOgre, "OGRE_NUM_SHADOW_EXTRUDER_PROGRAMS", SWIG_From_int(static_cast< int >(8)));
  
  SwigClassShadowVolumeExtrudeProgram.klass = rb_define_class_under(mOgre, "ShadowVolumeExtrudeProgram", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ShadowVolumeExtrudeProgram, (void *) &SwigClassShadowVolumeExtrudeProgram);
  rb_define_alloc_func(SwigClassShadowVolumeExtrudeProgram.klass, _wrap_ShadowVolumeExtrudeProgram_allocate);
  rb_define_method(SwigClassShadowVolumeExtrudeProgram.klass, "initialize", VALUEFUNC(_wrap_new_ShadowVolumeExtrudeProgram), -1);
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "POINT_LIGHT", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::POINT_LIGHT)));
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "POINT_LIGHT_DEBUG", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::POINT_LIGHT_DEBUG)));
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "DIRECTIONAL_LIGHT", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::DIRECTIONAL_LIGHT)));
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "DIRECTIONAL_LIGHT_DEBUG", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::DIRECTIONAL_LIGHT_DEBUG)));
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "POINT_LIGHT_FINITE", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::POINT_LIGHT_FINITE)));
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "POINT_LIGHT_FINITE_DEBUG", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::POINT_LIGHT_FINITE_DEBUG)));
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "DIRECTIONAL_LIGHT_FINITE", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::DIRECTIONAL_LIGHT_FINITE)));
  rb_define_const(SwigClassShadowVolumeExtrudeProgram.klass, "DIRECTIONAL_LIGHT_FINITE_DEBUG", SWIG_From_int(static_cast< int >(Ogre::ShadowVolumeExtrudeProgram::DIRECTIONAL_LIGHT_FINITE_DEBUG)));
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "programNames", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_programNames_get), 0);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "frgProgramName", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_frgProgramName_get), 0);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "frgProgramName=", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_frgProgramName_set), 1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "initialise", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_initialise), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "shutdown", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_shutdown), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderArbvp1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_1_1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_4_0", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_glsles", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glsles), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderArbvp1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_1_1", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_4_0", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_glsles", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glsles), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderArbvp1Debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1Debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_1_1Debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1Debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_4_0Debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0Debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_glslesDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glslesDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderArbvp1Debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1Debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_1_1Debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1Debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_4_0Debug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0Debug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_glslesDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glslesDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getProgramSource", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getProgramSource), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getProgramName", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getProgramName), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderArbvp1Finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1Finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_1_1Finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1Finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_4_0Finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0Finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_glslesFinite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glslesFinite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderArbvp1Finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1Finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_1_1Finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1Finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_4_0Finite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0Finite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_glslesFinite", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glslesFinite), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderArbvp1FiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderArbvp1FiniteDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_1_1FiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_1_1FiniteDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_4_0FiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_4_0FiniteDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getPointLightExtruderVs_glslesFiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getPointLightExtruderVs_glslesFiniteDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderArbvp1FiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderArbvp1FiniteDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_1_1FiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_1_1FiniteDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_4_0FiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_4_0FiniteDebug), -1);
  rb_define_singleton_method(SwigClassShadowVolumeExtrudeProgram.klass, "getDirectionalLightExtruderVs_glslesFiniteDebug", VALUEFUNC(_wrap_ShadowVolumeExtrudeProgram_getDirectionalLightExtruderVs_glslesFiniteDebug), -1);
  SwigClassShadowVolumeExtrudeProgram.mark = 0;
  SwigClassShadowVolumeExtrudeProgram.destroy = (void (*)(void *)) free_Ogre_ShadowVolumeExtrudeProgram;
  SwigClassShadowVolumeExtrudeProgram.trackObjects = 0;
  rb_define_const(mOgre, "SKELETON_HEADER", SWIG_From_int(static_cast< int >(Ogre::SKELETON_HEADER)));
  rb_define_const(mOgre, "SKELETON_BLENDMODE", SWIG_From_int(static_cast< int >(Ogre::SKELETON_BLENDMODE)));
  rb_define_const(mOgre, "SKELETON_BONE", SWIG_From_int(static_cast< int >(Ogre::SKELETON_BONE)));
  rb_define_const(mOgre, "SKELETON_BONE_PARENT", SWIG_From_int(static_cast< int >(Ogre::SKELETON_BONE_PARENT)));
  rb_define_const(mOgre, "SKELETON_ANIMATION", SWIG_From_int(static_cast< int >(Ogre::SKELETON_ANIMATION)));
  rb_define_const(mOgre, "SKELETON_ANIMATION_BASEINFO", SWIG_From_int(static_cast< int >(Ogre::SKELETON_ANIMATION_BASEINFO)));
  rb_define_const(mOgre, "SKELETON_ANIMATION_TRACK", SWIG_From_int(static_cast< int >(Ogre::SKELETON_ANIMATION_TRACK)));
  rb_define_const(mOgre, "SKELETON_ANIMATION_TRACK_KEYFRAME", SWIG_From_int(static_cast< int >(Ogre::SKELETON_ANIMATION_TRACK_KEYFRAME)));
  rb_define_const(mOgre, "SKELETON_ANIMATION_LINK", SWIG_From_int(static_cast< int >(Ogre::SKELETON_ANIMATION_LINK)));
  
  SwigClassSkeletonManager.klass = rb_define_class_under(mOgre, "SkeletonManager", ((swig_class *) SWIGTYPE_p_Ogre__ResourceManager->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SkeletonManager, (void *) &SwigClassSkeletonManager);
  rb_define_alloc_func(SwigClassSkeletonManager.klass, _wrap_SkeletonManager_allocate);
  rb_define_method(SwigClassSkeletonManager.klass, "initialize", VALUEFUNC(_wrap_new_SkeletonManager), -1);
  rb_define_singleton_method(SwigClassSkeletonManager.klass, "getSingleton", VALUEFUNC(_wrap_SkeletonManager_getSingleton), -1);
  rb_define_singleton_method(SwigClassSkeletonManager.klass, "getSingletonPtr", VALUEFUNC(_wrap_SkeletonManager_getSingletonPtr), -1);
  SwigClassSkeletonManager.mark = 0;
  SwigClassSkeletonManager.destroy = (void (*)(void *)) free_Ogre_SkeletonManager;
  SwigClassSkeletonManager.trackObjects = 0;
  rb_define_const(mOgre, "SKELETON_VERSION_1_0", SWIG_From_int(static_cast< int >(Ogre::SKELETON_VERSION_1_0)));
  rb_define_const(mOgre, "SKELETON_VERSION_1_8", SWIG_From_int(static_cast< int >(Ogre::SKELETON_VERSION_1_8)));
  rb_define_const(mOgre, "SKELETON_VERSION_LATEST", SWIG_From_int(static_cast< int >(Ogre::SKELETON_VERSION_LATEST)));
  
  SwigClassSkeletonSerializer.klass = rb_define_class_under(mOgre, "SkeletonSerializer", ((swig_class *) SWIGTYPE_p_Ogre__Serializer->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SkeletonSerializer, (void *) &SwigClassSkeletonSerializer);
  rb_define_alloc_func(SwigClassSkeletonSerializer.klass, _wrap_SkeletonSerializer_allocate);
  rb_define_method(SwigClassSkeletonSerializer.klass, "initialize", VALUEFUNC(_wrap_new_SkeletonSerializer), -1);
  rb_define_method(SwigClassSkeletonSerializer.klass, "exportSkeleton", VALUEFUNC(_wrap_SkeletonSerializer_exportSkeleton), -1);
  rb_define_method(SwigClassSkeletonSerializer.klass, "importSkeleton", VALUEFUNC(_wrap_SkeletonSerializer_importSkeleton), -1);
  SwigClassSkeletonSerializer.mark = 0;
  SwigClassSkeletonSerializer.destroy = (void (*)(void *)) free_Ogre_SkeletonSerializer;
  SwigClassSkeletonSerializer.trackObjects = 0;
  rb_define_const(mOgre, "SPOT_SHADOW_FADE_PNG_SIZE", SWIG_From_int(static_cast< int >(9728)));
  rb_define_singleton_method(mOgre, "SPOT_SHADOW_FADE_PNG", VALUEFUNC(_wrap_SPOT_SHADOW_FADE_PNG_get), 0);
  rb_define_singleton_method(mOgre, "SPOT_SHADOW_FADE_PNG=", VALUEFUNC(_wrap_SPOT_SHADOW_FADE_PNG_set), 1);
  rb_define_const(mOgre, "FGT_FACE_LIST", SWIG_From_int(static_cast< int >(Ogre::FGT_FACE_LIST)));
  rb_define_const(mOgre, "FGT_PATCH", SWIG_From_int(static_cast< int >(Ogre::FGT_PATCH)));
  rb_define_const(mOgre, "FGT_UNKNOWN", SWIG_From_int(static_cast< int >(Ogre::FGT_UNKNOWN)));
  
  SwigClassStaticFaceGroup.klass = rb_define_class_under(mOgre, "StaticFaceGroup", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__StaticFaceGroup, (void *) &SwigClassStaticFaceGroup);
  rb_define_alloc_func(SwigClassStaticFaceGroup.klass, _wrap_StaticFaceGroup_allocate);
  rb_define_method(SwigClassStaticFaceGroup.klass, "initialize", VALUEFUNC(_wrap_new_StaticFaceGroup), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "fType=", VALUEFUNC(_wrap_StaticFaceGroup_fType_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "fType", VALUEFUNC(_wrap_StaticFaceGroup_fType_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "isSky=", VALUEFUNC(_wrap_StaticFaceGroup_isSky_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "isSky", VALUEFUNC(_wrap_StaticFaceGroup_isSky_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "vertexStart=", VALUEFUNC(_wrap_StaticFaceGroup_vertexStart_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "vertexStart", VALUEFUNC(_wrap_StaticFaceGroup_vertexStart_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "numVertices=", VALUEFUNC(_wrap_StaticFaceGroup_numVertices_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "numVertices", VALUEFUNC(_wrap_StaticFaceGroup_numVertices_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "elementStart=", VALUEFUNC(_wrap_StaticFaceGroup_elementStart_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "elementStart", VALUEFUNC(_wrap_StaticFaceGroup_elementStart_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "numElements=", VALUEFUNC(_wrap_StaticFaceGroup_numElements_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "numElements", VALUEFUNC(_wrap_StaticFaceGroup_numElements_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "materialHandle=", VALUEFUNC(_wrap_StaticFaceGroup_materialHandle_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "materialHandle", VALUEFUNC(_wrap_StaticFaceGroup_materialHandle_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "plane=", VALUEFUNC(_wrap_StaticFaceGroup_plane_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "plane", VALUEFUNC(_wrap_StaticFaceGroup_plane_get), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "patchSurf=", VALUEFUNC(_wrap_StaticFaceGroup_patchSurf_set), -1);
  rb_define_method(SwigClassStaticFaceGroup.klass, "patchSurf", VALUEFUNC(_wrap_StaticFaceGroup_patchSurf_get), -1);
  SwigClassStaticFaceGroup.mark = 0;
  SwigClassStaticFaceGroup.destroy = (void (*)(void *)) free_Ogre_StaticFaceGroup;
  SwigClassStaticFaceGroup.trackObjects = 0;
  
  SwigClassStaticGeometry.klass = rb_define_class_under(mOgre, "StaticGeometry", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__StaticGeometry, (void *) &SwigClassStaticGeometry);
  rb_define_alloc_func(SwigClassStaticGeometry.klass, _wrap_StaticGeometry_allocate);
  rb_define_method(SwigClassStaticGeometry.klass, "initialize", VALUEFUNC(_wrap_new_StaticGeometry), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getName", VALUEFUNC(_wrap_StaticGeometry_getName), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "addEntity", VALUEFUNC(_wrap_StaticGeometry_addEntity), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "addSceneNode", VALUEFUNC(_wrap_StaticGeometry_addSceneNode), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "build", VALUEFUNC(_wrap_StaticGeometry_build), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "destroy", VALUEFUNC(_wrap_StaticGeometry_destroy), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "reset", VALUEFUNC(_wrap_StaticGeometry_reset), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "setRenderingDistance", VALUEFUNC(_wrap_StaticGeometry_setRenderingDistance), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getRenderingDistance", VALUEFUNC(_wrap_StaticGeometry_getRenderingDistance), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getSquaredRenderingDistance", VALUEFUNC(_wrap_StaticGeometry_getSquaredRenderingDistance), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "setVisible", VALUEFUNC(_wrap_StaticGeometry_setVisible), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "isVisible", VALUEFUNC(_wrap_StaticGeometry_isVisible), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "setCastShadows", VALUEFUNC(_wrap_StaticGeometry_setCastShadows), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getCastShadows", VALUEFUNC(_wrap_StaticGeometry_getCastShadows), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "setRegionDimensions", VALUEFUNC(_wrap_StaticGeometry_setRegionDimensions), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getRegionDimensions", VALUEFUNC(_wrap_StaticGeometry_getRegionDimensions), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "setOrigin", VALUEFUNC(_wrap_StaticGeometry_setOrigin), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getOrigin", VALUEFUNC(_wrap_StaticGeometry_getOrigin), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "setVisibilityFlags", VALUEFUNC(_wrap_StaticGeometry_setVisibilityFlags), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getVisibilityFlags", VALUEFUNC(_wrap_StaticGeometry_getVisibilityFlags), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_StaticGeometry_setRenderQueueGroup), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getRenderQueueGroup", VALUEFUNC(_wrap_StaticGeometry_getRenderQueueGroup), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "visitRenderables", VALUEFUNC(_wrap_StaticGeometry_visitRenderables), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "getRegionIterator", VALUEFUNC(_wrap_StaticGeometry_getRegionIterator), -1);
  rb_define_method(SwigClassStaticGeometry.klass, "dump", VALUEFUNC(_wrap_StaticGeometry_dump), -1);
  SwigClassStaticGeometry.mark = 0;
  SwigClassStaticGeometry.destroy = (void (*)(void *)) free_Ogre_StaticGeometry;
  SwigClassStaticGeometry.trackObjects = 0;
  
  SwigClassStaticPluginLoader.klass = rb_define_class_under(mOgre, "StaticPluginLoader", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__StaticPluginLoader, (void *) &SwigClassStaticPluginLoader);
  rb_define_alloc_func(SwigClassStaticPluginLoader.klass, _wrap_StaticPluginLoader_allocate);
  rb_define_method(SwigClassStaticPluginLoader.klass, "initialize", VALUEFUNC(_wrap_new_StaticPluginLoader), -1);
  rb_define_method(SwigClassStaticPluginLoader.klass, "load", VALUEFUNC(_wrap_StaticPluginLoader_load), -1);
  rb_define_method(SwigClassStaticPluginLoader.klass, "unload", VALUEFUNC(_wrap_StaticPluginLoader_unload), -1);
  SwigClassStaticPluginLoader.mark = 0;
  SwigClassStaticPluginLoader.destroy = (void (*)(void *)) free_Ogre_StaticPluginLoader;
  SwigClassStaticPluginLoader.trackObjects = 0;
  
  SwigClassStreamSerialiser.klass = rb_define_class_under(mOgre, "StreamSerialiser", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__StreamSerialiser, (void *) &SwigClassStreamSerialiser);
  rb_define_alloc_func(SwigClassStreamSerialiser.klass, _wrap_StreamSerialiser_allocate);
  rb_define_method(SwigClassStreamSerialiser.klass, "initialize", VALUEFUNC(_wrap_new_StreamSerialiser), -1);
  rb_define_const(SwigClassStreamSerialiser.klass, "ENDIAN_AUTO", SWIG_From_int(static_cast< int >(Ogre::StreamSerialiser::ENDIAN_AUTO)));
  rb_define_const(SwigClassStreamSerialiser.klass, "ENDIAN_BIG", SWIG_From_int(static_cast< int >(Ogre::StreamSerialiser::ENDIAN_BIG)));
  rb_define_const(SwigClassStreamSerialiser.klass, "ENDIAN_LITTLE", SWIG_From_int(static_cast< int >(Ogre::StreamSerialiser::ENDIAN_LITTLE)));
  rb_define_const(SwigClassStreamSerialiser.klass, "REAL_FLOAT", SWIG_From_int(static_cast< int >(Ogre::StreamSerialiser::REAL_FLOAT)));
  rb_define_const(SwigClassStreamSerialiser.klass, "REAL_DOUBLE", SWIG_From_int(static_cast< int >(Ogre::StreamSerialiser::REAL_DOUBLE)));
  rb_define_method(SwigClassStreamSerialiser.klass, "getEndian", VALUEFUNC(_wrap_StreamSerialiser_getEndian), -1);
  rb_define_singleton_method(SwigClassStreamSerialiser.klass, "makeIdentifier", VALUEFUNC(_wrap_StreamSerialiser_makeIdentifier), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "getCurrentChunkDepth", VALUEFUNC(_wrap_StreamSerialiser_getCurrentChunkDepth), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "getCurrentChunkID", VALUEFUNC(_wrap_StreamSerialiser_getCurrentChunkID), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "getOffsetFromChunkStart", VALUEFUNC(_wrap_StreamSerialiser_getOffsetFromChunkStart), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "readChunkBegin", VALUEFUNC(_wrap_StreamSerialiser_readChunkBegin), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "undoReadChunk", VALUEFUNC(_wrap_StreamSerialiser_undoReadChunk), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "peekNextChunkID", VALUEFUNC(_wrap_StreamSerialiser_peekNextChunkID), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "readChunkEnd", VALUEFUNC(_wrap_StreamSerialiser_readChunkEnd), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "isEndOfChunk", VALUEFUNC(_wrap_StreamSerialiser_isEndOfChunk), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "eof", VALUEFUNC(_wrap_StreamSerialiser_eof), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "getCurrentChunk", VALUEFUNC(_wrap_StreamSerialiser_getCurrentChunk), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "writeChunkBegin", VALUEFUNC(_wrap_StreamSerialiser_writeChunkBegin), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "writeChunkEnd", VALUEFUNC(_wrap_StreamSerialiser_writeChunkEnd), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "writeData", VALUEFUNC(_wrap_StreamSerialiser_writeData), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "write", VALUEFUNC(_wrap_StreamSerialiser_write), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "readData", VALUEFUNC(_wrap_StreamSerialiser_readData), -1);
  rb_define_method(SwigClassStreamSerialiser.klass, "read", VALUEFUNC(_wrap_StreamSerialiser_read), -1);
  SwigClassStreamSerialiser.mark = 0;
  SwigClassStreamSerialiser.destroy = (void (*)(void *)) free_Ogre_StreamSerialiser;
  SwigClassStreamSerialiser.trackObjects = 0;
  
  SwigClassSubEntity.klass = rb_define_class_under(mOgre, "SubEntity", ((swig_class *) SWIGTYPE_p_Ogre__Renderable->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SubEntity, (void *) &SwigClassSubEntity);
  rb_undef_alloc_func(SwigClassSubEntity.klass);
  rb_define_method(SwigClassSubEntity.klass, "getMaterialName", VALUEFUNC(_wrap_SubEntity_getMaterialName), -1);
  rb_define_method(SwigClassSubEntity.klass, "setMaterialName", VALUEFUNC(_wrap_SubEntity_setMaterialName), -1);
  rb_define_method(SwigClassSubEntity.klass, "setMaterial", VALUEFUNC(_wrap_SubEntity_setMaterial), -1);
  rb_define_method(SwigClassSubEntity.klass, "setVisible", VALUEFUNC(_wrap_SubEntity_setVisible), -1);
  rb_define_method(SwigClassSubEntity.klass, "isVisible", VALUEFUNC(_wrap_SubEntity_isVisible), -1);
  rb_define_method(SwigClassSubEntity.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_SubEntity_setRenderQueueGroup), -1);
  rb_define_method(SwigClassSubEntity.klass, "setRenderQueueGroupAndPriority", VALUEFUNC(_wrap_SubEntity_setRenderQueueGroupAndPriority), -1);
  rb_define_method(SwigClassSubEntity.klass, "getRenderQueueGroup", VALUEFUNC(_wrap_SubEntity_getRenderQueueGroup), -1);
  rb_define_method(SwigClassSubEntity.klass, "getRenderQueuePriority", VALUEFUNC(_wrap_SubEntity_getRenderQueuePriority), -1);
  rb_define_method(SwigClassSubEntity.klass, "isRenderQueueGroupSet", VALUEFUNC(_wrap_SubEntity_isRenderQueueGroupSet), -1);
  rb_define_method(SwigClassSubEntity.klass, "isRenderQueuePrioritySet", VALUEFUNC(_wrap_SubEntity_isRenderQueuePrioritySet), -1);
  rb_define_method(SwigClassSubEntity.klass, "getSubMesh", VALUEFUNC(_wrap_SubEntity_getSubMesh), -1);
  rb_define_method(SwigClassSubEntity.klass, "getParent", VALUEFUNC(_wrap_SubEntity_getParent), -1);
  rb_define_method(SwigClassSubEntity.klass, "getMaterial", VALUEFUNC(_wrap_SubEntity_getMaterial), -1);
  rb_define_method(SwigClassSubEntity.klass, "getTechnique", VALUEFUNC(_wrap_SubEntity_getTechnique), -1);
  rb_define_method(SwigClassSubEntity.klass, "getRenderOperation", VALUEFUNC(_wrap_SubEntity_getRenderOperation), -1);
  rb_define_method(SwigClassSubEntity.klass, "getWorldTransforms", VALUEFUNC(_wrap_SubEntity_getWorldTransforms), -1);
  rb_define_method(SwigClassSubEntity.klass, "getNumWorldTransforms", VALUEFUNC(_wrap_SubEntity_getNumWorldTransforms), -1);
  rb_define_method(SwigClassSubEntity.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_SubEntity_getSquaredViewDepth), -1);
  rb_define_method(SwigClassSubEntity.klass, "getLights", VALUEFUNC(_wrap_SubEntity_getLights), -1);
  rb_define_method(SwigClassSubEntity.klass, "getCastsShadows", VALUEFUNC(_wrap_SubEntity_getCastsShadows), -1);
  rb_define_method(SwigClassSubEntity.klass, "_getSkelAnimVertexData", VALUEFUNC(_wrap_SubEntity__getSkelAnimVertexData), -1);
  rb_define_method(SwigClassSubEntity.klass, "_getSoftwareVertexAnimVertexData", VALUEFUNC(_wrap_SubEntity__getSoftwareVertexAnimVertexData), -1);
  rb_define_method(SwigClassSubEntity.klass, "_getHardwareVertexAnimVertexData", VALUEFUNC(_wrap_SubEntity__getHardwareVertexAnimVertexData), -1);
  rb_define_method(SwigClassSubEntity.klass, "_getSkelAnimTempBufferInfo", VALUEFUNC(_wrap_SubEntity__getSkelAnimTempBufferInfo), -1);
  rb_define_method(SwigClassSubEntity.klass, "_getVertexAnimTempBufferInfo", VALUEFUNC(_wrap_SubEntity__getVertexAnimTempBufferInfo), -1);
  rb_define_method(SwigClassSubEntity.klass, "getVertexDataForBinding", VALUEFUNC(_wrap_SubEntity_getVertexDataForBinding), -1);
  rb_define_method(SwigClassSubEntity.klass, "_markBuffersUnusedForAnimation", VALUEFUNC(_wrap_SubEntity__markBuffersUnusedForAnimation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_markBuffersUsedForAnimation", VALUEFUNC(_wrap_SubEntity__markBuffersUsedForAnimation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_getBuffersMarkedForAnimation", VALUEFUNC(_wrap_SubEntity__getBuffersMarkedForAnimation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_restoreBuffersForUnusedAnimation", VALUEFUNC(_wrap_SubEntity__restoreBuffersForUnusedAnimation), -1);
  rb_define_method(SwigClassSubEntity.klass, "_updateCustomGpuParameter", VALUEFUNC(_wrap_SubEntity__updateCustomGpuParameter), -1);
  rb_define_method(SwigClassSubEntity.klass, "_invalidateCameraCache", VALUEFUNC(_wrap_SubEntity__invalidateCameraCache), -1);
  SwigClassSubEntity.mark = 0;
  SwigClassSubEntity.trackObjects = 0;
  
  SwigClassSubMesh.klass = rb_define_class_under(mOgre, "SubMesh", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SubMesh, (void *) &SwigClassSubMesh);
  rb_define_alloc_func(SwigClassSubMesh.klass, _wrap_SubMesh_allocate);
  rb_define_method(SwigClassSubMesh.klass, "initialize", VALUEFUNC(_wrap_new_SubMesh), -1);
  rb_define_method(SwigClassSubMesh.klass, "useSharedVertices=", VALUEFUNC(_wrap_SubMesh_useSharedVertices_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "useSharedVertices", VALUEFUNC(_wrap_SubMesh_useSharedVertices_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "operationType=", VALUEFUNC(_wrap_SubMesh_operationType_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "operationType", VALUEFUNC(_wrap_SubMesh_operationType_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "vertexData=", VALUEFUNC(_wrap_SubMesh_vertexData_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "vertexData", VALUEFUNC(_wrap_SubMesh_vertexData_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "indexData=", VALUEFUNC(_wrap_SubMesh_indexData_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "indexData", VALUEFUNC(_wrap_SubMesh_indexData_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "blendIndexToBoneIndexMap=", VALUEFUNC(_wrap_SubMesh_blendIndexToBoneIndexMap_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "blendIndexToBoneIndexMap", VALUEFUNC(_wrap_SubMesh_blendIndexToBoneIndexMap_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "mLodFaceList=", VALUEFUNC(_wrap_SubMesh_mLodFaceList_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "mLodFaceList", VALUEFUNC(_wrap_SubMesh_mLodFaceList_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "extremityPoints=", VALUEFUNC(_wrap_SubMesh_extremityPoints_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "extremityPoints", VALUEFUNC(_wrap_SubMesh_extremityPoints_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "parent=", VALUEFUNC(_wrap_SubMesh_parent_set), -1);
  rb_define_method(SwigClassSubMesh.klass, "parent", VALUEFUNC(_wrap_SubMesh_parent_get), -1);
  rb_define_method(SwigClassSubMesh.klass, "setMaterialName", VALUEFUNC(_wrap_SubMesh_setMaterialName), -1);
  rb_define_method(SwigClassSubMesh.klass, "getMaterialName", VALUEFUNC(_wrap_SubMesh_getMaterialName), -1);
  rb_define_method(SwigClassSubMesh.klass, "isMatInitialised", VALUEFUNC(_wrap_SubMesh_isMatInitialised), -1);
  rb_define_method(SwigClassSubMesh.klass, "_getRenderOperation", VALUEFUNC(_wrap_SubMesh__getRenderOperation), -1);
  rb_define_method(SwigClassSubMesh.klass, "addBoneAssignment", VALUEFUNC(_wrap_SubMesh_addBoneAssignment), -1);
  rb_define_method(SwigClassSubMesh.klass, "clearBoneAssignments", VALUEFUNC(_wrap_SubMesh_clearBoneAssignments), -1);
  rb_define_method(SwigClassSubMesh.klass, "getBoneAssignmentIterator", VALUEFUNC(_wrap_SubMesh_getBoneAssignmentIterator), -1);
  rb_define_method(SwigClassSubMesh.klass, "getBoneAssignments", VALUEFUNC(_wrap_SubMesh_getBoneAssignments), -1);
  rb_define_method(SwigClassSubMesh.klass, "_compileBoneAssignments", VALUEFUNC(_wrap_SubMesh__compileBoneAssignments), -1);
  rb_define_method(SwigClassSubMesh.klass, "getAliasTextureIterator", VALUEFUNC(_wrap_SubMesh_getAliasTextureIterator), -1);
  rb_define_method(SwigClassSubMesh.klass, "addTextureAlias", VALUEFUNC(_wrap_SubMesh_addTextureAlias), -1);
  rb_define_method(SwigClassSubMesh.klass, "removeTextureAlias", VALUEFUNC(_wrap_SubMesh_removeTextureAlias), -1);
  rb_define_method(SwigClassSubMesh.klass, "removeAllTextureAliases", VALUEFUNC(_wrap_SubMesh_removeAllTextureAliases), -1);
  rb_define_method(SwigClassSubMesh.klass, "hasTextureAliases", VALUEFUNC(_wrap_SubMesh_hasTextureAliases), -1);
  rb_define_method(SwigClassSubMesh.klass, "getTextureAliasCount", VALUEFUNC(_wrap_SubMesh_getTextureAliasCount), -1);
  rb_define_method(SwigClassSubMesh.klass, "updateMaterialUsingTextureAliases", VALUEFUNC(_wrap_SubMesh_updateMaterialUsingTextureAliases), -1);
  rb_define_method(SwigClassSubMesh.klass, "getVertexAnimationType", VALUEFUNC(_wrap_SubMesh_getVertexAnimationType), -1);
  rb_define_method(SwigClassSubMesh.klass, "getVertexAnimationIncludesNormals", VALUEFUNC(_wrap_SubMesh_getVertexAnimationIncludesNormals), -1);
  rb_define_method(SwigClassSubMesh.klass, "generateExtremes", VALUEFUNC(_wrap_SubMesh_generateExtremes), -1);
  rb_define_method(SwigClassSubMesh.klass, "isBuildEdgesEnabled", VALUEFUNC(_wrap_SubMesh_isBuildEdgesEnabled), -1);
  rb_define_method(SwigClassSubMesh.klass, "setBuildEdgesEnabled", VALUEFUNC(_wrap_SubMesh_setBuildEdgesEnabled), -1);
  SwigClassSubMesh.mark = 0;
  SwigClassSubMesh.destroy = (void (*)(void *)) free_Ogre_SubMesh;
  SwigClassSubMesh.trackObjects = 0;
  
  SwigClassTagPoint.klass = rb_define_class_under(mOgre, "TagPoint", ((swig_class *) SWIGTYPE_p_Ogre__Bone->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TagPoint, (void *) &SwigClassTagPoint);
  rb_define_alloc_func(SwigClassTagPoint.klass, _wrap_TagPoint_allocate);
  rb_define_method(SwigClassTagPoint.klass, "initialize", VALUEFUNC(_wrap_new_TagPoint), -1);
  rb_define_method(SwigClassTagPoint.klass, "getParentEntity", VALUEFUNC(_wrap_TagPoint_getParentEntity), -1);
  rb_define_method(SwigClassTagPoint.klass, "getChildObject", VALUEFUNC(_wrap_TagPoint_getChildObject), -1);
  rb_define_method(SwigClassTagPoint.klass, "setParentEntity", VALUEFUNC(_wrap_TagPoint_setParentEntity), -1);
  rb_define_method(SwigClassTagPoint.klass, "setChildObject", VALUEFUNC(_wrap_TagPoint_setChildObject), -1);
  rb_define_method(SwigClassTagPoint.klass, "setInheritParentEntityOrientation", VALUEFUNC(_wrap_TagPoint_setInheritParentEntityOrientation), -1);
  rb_define_method(SwigClassTagPoint.klass, "getInheritParentEntityOrientation", VALUEFUNC(_wrap_TagPoint_getInheritParentEntityOrientation), -1);
  rb_define_method(SwigClassTagPoint.klass, "setInheritParentEntityScale", VALUEFUNC(_wrap_TagPoint_setInheritParentEntityScale), -1);
  rb_define_method(SwigClassTagPoint.klass, "getInheritParentEntityScale", VALUEFUNC(_wrap_TagPoint_getInheritParentEntityScale), -1);
  rb_define_method(SwigClassTagPoint.klass, "getParentEntityTransform", VALUEFUNC(_wrap_TagPoint_getParentEntityTransform), -1);
  rb_define_method(SwigClassTagPoint.klass, "_getFullLocalTransform", VALUEFUNC(_wrap_TagPoint__getFullLocalTransform), -1);
  rb_define_method(SwigClassTagPoint.klass, "needUpdate", VALUEFUNC(_wrap_TagPoint_needUpdate), -1);
  rb_define_method(SwigClassTagPoint.klass, "updateFromParentImpl", VALUEFUNC(_wrap_TagPoint_updateFromParentImpl), -1);
  rb_define_method(SwigClassTagPoint.klass, "getLights", VALUEFUNC(_wrap_TagPoint_getLights), -1);
  SwigClassTagPoint.mark = 0;
  SwigClassTagPoint.destroy = (void (*)(void *)) free_Ogre_TagPoint;
  SwigClassTagPoint.trackObjects = 0;
  
  SwigClassTangentSpaceCalc.klass = rb_define_class_under(mOgre, "TangentSpaceCalc", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TangentSpaceCalc, (void *) &SwigClassTangentSpaceCalc);
  rb_define_alloc_func(SwigClassTangentSpaceCalc.klass, _wrap_TangentSpaceCalc_allocate);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "initialize", VALUEFUNC(_wrap_new_TangentSpaceCalc), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "clear", VALUEFUNC(_wrap_TangentSpaceCalc_clear), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "setVertexData", VALUEFUNC(_wrap_TangentSpaceCalc_setVertexData), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "addIndexData", VALUEFUNC(_wrap_TangentSpaceCalc_addIndexData), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "setStoreParityInW", VALUEFUNC(_wrap_TangentSpaceCalc_setStoreParityInW), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "getStoreParityInW", VALUEFUNC(_wrap_TangentSpaceCalc_getStoreParityInW), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "setSplitMirrored", VALUEFUNC(_wrap_TangentSpaceCalc_setSplitMirrored), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "getSplitMirrored", VALUEFUNC(_wrap_TangentSpaceCalc_getSplitMirrored), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "setSplitRotated", VALUEFUNC(_wrap_TangentSpaceCalc_setSplitRotated), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "getSplitRotated", VALUEFUNC(_wrap_TangentSpaceCalc_getSplitRotated), -1);
  rb_define_method(SwigClassTangentSpaceCalc.klass, "build", VALUEFUNC(_wrap_TangentSpaceCalc_build), -1);
  SwigClassTangentSpaceCalc.mark = 0;
  SwigClassTangentSpaceCalc.destroy = (void (*)(void *)) free_Ogre_TangentSpaceCalc;
  SwigClassTangentSpaceCalc.trackObjects = 0;
  
  SwigClassUnifiedHighLevelGpuProgram.klass = rb_define_class_under(mOgre, "UnifiedHighLevelGpuProgram", ((swig_class *) SWIGTYPE_p_Ogre__HighLevelGpuProgram->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__UnifiedHighLevelGpuProgram, (void *) &SwigClassUnifiedHighLevelGpuProgram);
  rb_define_alloc_func(SwigClassUnifiedHighLevelGpuProgram.klass, _wrap_UnifiedHighLevelGpuProgram_allocate);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "initialize", VALUEFUNC(_wrap_new_UnifiedHighLevelGpuProgram), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "addDelegateProgram", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_addDelegateProgram), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "clearDelegatePrograms", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_clearDelegatePrograms), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "_getDelegate", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram__getDelegate), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "getLanguage", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_getLanguage), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "createParameters", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_createParameters), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "_getBindingDelegate", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram__getBindingDelegate), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isSupported", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isSupported), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isSkeletalAnimationIncluded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isSkeletalAnimationIncluded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isMorphAnimationIncluded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isMorphAnimationIncluded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isPoseAnimationIncluded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isPoseAnimationIncluded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isVertexTextureFetchRequired", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isVertexTextureFetchRequired), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "getDefaultParameters", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_getDefaultParameters), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "hasDefaultParameters", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_hasDefaultParameters), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "getPassSurfaceAndLightStates", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_getPassSurfaceAndLightStates), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "getPassFogStates", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_getPassFogStates), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "getPassTransformStates", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_getPassTransformStates), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "hasCompileError", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_hasCompileError), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "resetCompileError", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_resetCompileError), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "load", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_load), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "reload", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_reload), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isReloadable", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isReloadable), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isLoaded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isLoaded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isLoading", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isLoading), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "getLoadingState", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_getLoadingState), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "unload", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_unload), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "getSize", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_getSize), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "touch", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_touch), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "isBackgroundLoaded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_isBackgroundLoaded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "setBackgroundLoaded", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_setBackgroundLoaded), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "escalateLoading", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_escalateLoading), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "addListener", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_addListener), -1);
  rb_define_method(SwigClassUnifiedHighLevelGpuProgram.klass, "removeListener", VALUEFUNC(_wrap_UnifiedHighLevelGpuProgram_removeListener), -1);
  SwigClassUnifiedHighLevelGpuProgram.mark = 0;
  SwigClassUnifiedHighLevelGpuProgram.destroy = (void (*)(void *)) free_Ogre_UnifiedHighLevelGpuProgram;
  SwigClassUnifiedHighLevelGpuProgram.trackObjects = 0;
  
  SwigClassWindowEventListener.klass = rb_define_class_under(mOgre, "WindowEventListener", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__WindowEventListener, (void *) &SwigClassWindowEventListener);
  rb_define_alloc_func(SwigClassWindowEventListener.klass, _wrap_WindowEventListener_allocate);
  rb_define_method(SwigClassWindowEventListener.klass, "initialize", VALUEFUNC(_wrap_new_WindowEventListener), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "windowMoved", VALUEFUNC(_wrap_WindowEventListener_windowMoved), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "windowResized", VALUEFUNC(_wrap_WindowEventListener_windowResized), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "windowClosing", VALUEFUNC(_wrap_WindowEventListener_windowClosing), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "windowClosed", VALUEFUNC(_wrap_WindowEventListener_windowClosed), -1);
  rb_define_method(SwigClassWindowEventListener.klass, "windowFocusChange", VALUEFUNC(_wrap_WindowEventListener_windowFocusChange), -1);
  SwigClassWindowEventListener.mark = 0;
  SwigClassWindowEventListener.destroy = (void (*)(void *)) free_Ogre_WindowEventListener;
  SwigClassWindowEventListener.trackObjects = 0;
  
  SwigClassWindowEventUtilities.klass = rb_define_class_under(mOgre, "WindowEventUtilities", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__WindowEventUtilities, (void *) &SwigClassWindowEventUtilities);
  rb_define_alloc_func(SwigClassWindowEventUtilities.klass, _wrap_WindowEventUtilities_allocate);
  rb_define_method(SwigClassWindowEventUtilities.klass, "initialize", VALUEFUNC(_wrap_new_WindowEventUtilities), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "messagePump", VALUEFUNC(_wrap_WindowEventUtilities_messagePump), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "addWindowEventListener", VALUEFUNC(_wrap_WindowEventUtilities_addWindowEventListener), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "removeWindowEventListener", VALUEFUNC(_wrap_WindowEventUtilities_removeWindowEventListener), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_addRenderWindow", VALUEFUNC(_wrap_WindowEventUtilities__addRenderWindow), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_removeRenderWindow", VALUEFUNC(_wrap_WindowEventUtilities__removeRenderWindow), -1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_msListeners", VALUEFUNC(_wrap_WindowEventUtilities__msListeners_get), 0);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_msListeners=", VALUEFUNC(_wrap_WindowEventUtilities__msListeners_set), 1);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_msWindows", VALUEFUNC(_wrap_WindowEventUtilities__msWindows_get), 0);
  rb_define_singleton_method(SwigClassWindowEventUtilities.klass, "_msWindows=", VALUEFUNC(_wrap_WindowEventUtilities__msWindows_set), 1);
  SwigClassWindowEventUtilities.mark = 0;
  SwigClassWindowEventUtilities.destroy = (void (*)(void *)) free_Ogre_WindowEventUtilities;
  SwigClassWindowEventUtilities.trackObjects = 0;
  
  SwigClassWireBoundingBox.klass = rb_define_class_under(mOgre, "WireBoundingBox", ((swig_class *) SWIGTYPE_p_Ogre__SimpleRenderable->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__WireBoundingBox, (void *) &SwigClassWireBoundingBox);
  rb_define_alloc_func(SwigClassWireBoundingBox.klass, _wrap_WireBoundingBox_allocate);
  rb_define_method(SwigClassWireBoundingBox.klass, "initialize", VALUEFUNC(_wrap_new_WireBoundingBox), -1);
  rb_define_method(SwigClassWireBoundingBox.klass, "setupBoundingBox", VALUEFUNC(_wrap_WireBoundingBox_setupBoundingBox), -1);
  rb_define_method(SwigClassWireBoundingBox.klass, "getSquaredViewDepth", VALUEFUNC(_wrap_WireBoundingBox_getSquaredViewDepth), -1);
  rb_define_method(SwigClassWireBoundingBox.klass, "getBoundingRadius", VALUEFUNC(_wrap_WireBoundingBox_getBoundingRadius), -1);
  SwigClassWireBoundingBox.mark = 0;
  SwigClassWireBoundingBox.destroy = (void (*)(void *)) free_Ogre_WireBoundingBox;
  SwigClassWireBoundingBox.trackObjects = 0;
  
  SwigClassZipArchive.klass = rb_define_class_under(mOgre, "ZipArchive", ((swig_class *) SWIGTYPE_p_Ogre__Archive->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__ZipArchive, (void *) &SwigClassZipArchive);
  rb_define_alloc_func(SwigClassZipArchive.klass, _wrap_ZipArchive_allocate);
  rb_define_method(SwigClassZipArchive.klass, "initialize", VALUEFUNC(_wrap_new_ZipArchive), -1);
  rb_define_method(SwigClassZipArchive.klass, "isCaseSensitive", VALUEFUNC(_wrap_ZipArchive_isCaseSensitive), -1);
  rb_define_method(SwigClassZipArchive.klass, "load", VALUEFUNC(_wrap_ZipArchive_load), -1);
  rb_define_method(SwigClassZipArchive.klass, "unload", VALUEFUNC(_wrap_ZipArchive_unload), -1);
  rb_define_method(SwigClassZipArchive.klass, "open", VALUEFUNC(_wrap_ZipArchive_open), -1);
  rb_define_method(SwigClassZipArchive.klass, "create", VALUEFUNC(_wrap_ZipArchive_create), -1);
  rb_define_method(SwigClassZipArchive.klass, "remove", VALUEFUNC(_wrap_ZipArchive_remove), -1);
  rb_define_method(SwigClassZipArchive.klass, "list", VALUEFUNC(_wrap_ZipArchive_list), -1);
  rb_define_method(SwigClassZipArchive.klass, "listFileInfo", VALUEFUNC(_wrap_ZipArchive_listFileInfo), -1);
  rb_define_method(SwigClassZipArchive.klass, "find", VALUEFUNC(_wrap_ZipArchive_find), -1);
  rb_define_method(SwigClassZipArchive.klass, "findFileInfo", VALUEFUNC(_wrap_ZipArchive_findFileInfo), -1);
  rb_define_method(SwigClassZipArchive.klass, "exists", VALUEFUNC(_wrap_ZipArchive_exists), -1);
  rb_define_method(SwigClassZipArchive.klass, "getModifiedTime", VALUEFUNC(_wrap_ZipArchive_getModifiedTime), -1);
  SwigClassZipArchive.mark = 0;
  SwigClassZipArchive.destroy = (void (*)(void *)) free_Ogre_ZipArchive;
  SwigClassZipArchive.trackObjects = 0;
  
  SwigClassEmbeddedZipArchiveFactory.klass = rb_define_class_under(mOgre, "EmbeddedZipArchiveFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__EmbeddedZipArchiveFactory, (void *) &SwigClassEmbeddedZipArchiveFactory);
  rb_define_alloc_func(SwigClassEmbeddedZipArchiveFactory.klass, _wrap_EmbeddedZipArchiveFactory_allocate);
  rb_define_method(SwigClassEmbeddedZipArchiveFactory.klass, "initialize", VALUEFUNC(_wrap_new_EmbeddedZipArchiveFactory), -1);
  rb_define_method(SwigClassEmbeddedZipArchiveFactory.klass, "getType", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_getType), -1);
  rb_define_method(SwigClassEmbeddedZipArchiveFactory.klass, "createInstance", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_createInstance), -1);
  rb_define_singleton_method(SwigClassEmbeddedZipArchiveFactory.klass, "addEmbbeddedFile", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_addEmbbeddedFile), -1);
  rb_define_singleton_method(SwigClassEmbeddedZipArchiveFactory.klass, "removeEmbbeddedFile", VALUEFUNC(_wrap_EmbeddedZipArchiveFactory_removeEmbbeddedFile), -1);
  SwigClassEmbeddedZipArchiveFactory.mark = 0;
  SwigClassEmbeddedZipArchiveFactory.destroy = (void (*)(void *)) free_Ogre_EmbeddedZipArchiveFactory;
  SwigClassEmbeddedZipArchiveFactory.trackObjects = 0;
  
  SwigClassPageStrategyData.klass = rb_define_class_under(mOgre, "PageStrategyData", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageStrategyData, (void *) &SwigClassPageStrategyData);
  rb_undef_alloc_func(SwigClassPageStrategyData.klass);
  rb_define_method(SwigClassPageStrategyData.klass, "load", VALUEFUNC(_wrap_PageStrategyData_load), -1);
  rb_define_method(SwigClassPageStrategyData.klass, "save", VALUEFUNC(_wrap_PageStrategyData_save), -1);
  SwigClassPageStrategyData.mark = 0;
  SwigClassPageStrategyData.destroy = (void (*)(void *)) free_Ogre_PageStrategyData;
  SwigClassPageStrategyData.trackObjects = 0;
  
  SwigClassPageStrategy.klass = rb_define_class_under(mOgre, "PageStrategy", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageStrategy, (void *) &SwigClassPageStrategy);
  rb_undef_alloc_func(SwigClassPageStrategy.klass);
  rb_define_method(SwigClassPageStrategy.klass, "getName", VALUEFUNC(_wrap_PageStrategy_getName), -1);
  rb_define_method(SwigClassPageStrategy.klass, "getManager", VALUEFUNC(_wrap_PageStrategy_getManager), -1);
  rb_define_method(SwigClassPageStrategy.klass, "frameStart", VALUEFUNC(_wrap_PageStrategy_frameStart), -1);
  rb_define_method(SwigClassPageStrategy.klass, "frameEnd", VALUEFUNC(_wrap_PageStrategy_frameEnd), -1);
  rb_define_method(SwigClassPageStrategy.klass, "notifyCamera", VALUEFUNC(_wrap_PageStrategy_notifyCamera), -1);
  rb_define_method(SwigClassPageStrategy.klass, "createData", VALUEFUNC(_wrap_PageStrategy_createData), -1);
  rb_define_method(SwigClassPageStrategy.klass, "destroyData", VALUEFUNC(_wrap_PageStrategy_destroyData), -1);
  rb_define_method(SwigClassPageStrategy.klass, "updateDebugDisplay", VALUEFUNC(_wrap_PageStrategy_updateDebugDisplay), -1);
  rb_define_method(SwigClassPageStrategy.klass, "getPageID", VALUEFUNC(_wrap_PageStrategy_getPageID), -1);
  SwigClassPageStrategy.mark = 0;
  SwigClassPageStrategy.destroy = (void (*)(void *)) free_Ogre_PageStrategy;
  SwigClassPageStrategy.trackObjects = 0;
  rb_define_const(mOgre, "G2D_X_Z", SWIG_From_int(static_cast< int >(Ogre::G2D_X_Z)));
  rb_define_const(mOgre, "G2D_X_Y", SWIG_From_int(static_cast< int >(Ogre::G2D_X_Y)));
  rb_define_const(mOgre, "G2D_Y_Z", SWIG_From_int(static_cast< int >(Ogre::G2D_Y_Z)));
  
  SwigClassGrid2DPageStrategyData.klass = rb_define_class_under(mOgre, "Grid2DPageStrategyData", ((swig_class *) SWIGTYPE_p_Ogre__PageStrategyData->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Grid2DPageStrategyData, (void *) &SwigClassGrid2DPageStrategyData);
  rb_define_alloc_func(SwigClassGrid2DPageStrategyData.klass, _wrap_Grid2DPageStrategyData_allocate);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "initialize", VALUEFUNC(_wrap_new_Grid2DPageStrategyData), -1);
  rb_define_singleton_method(SwigClassGrid2DPageStrategyData.klass, "CHUNK_ID", VALUEFUNC(_wrap_Grid2DPageStrategyData_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassGrid2DPageStrategyData.klass, "CHUNK_VERSION", VALUEFUNC(_wrap_Grid2DPageStrategyData_CHUNK_VERSION_get), 0);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setMode", VALUEFUNC(_wrap_Grid2DPageStrategyData_setMode), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getMode", VALUEFUNC(_wrap_Grid2DPageStrategyData_getMode), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setOrigin", VALUEFUNC(_wrap_Grid2DPageStrategyData_setOrigin), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getOrigin", VALUEFUNC(_wrap_Grid2DPageStrategyData_getOrigin), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setCellSize", VALUEFUNC(_wrap_Grid2DPageStrategyData_setCellSize), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getCellSize", VALUEFUNC(_wrap_Grid2DPageStrategyData_getCellSize), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setLoadRadius", VALUEFUNC(_wrap_Grid2DPageStrategyData_setLoadRadius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getLoadRadius", VALUEFUNC(_wrap_Grid2DPageStrategyData_getLoadRadius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setHoldRadius", VALUEFUNC(_wrap_Grid2DPageStrategyData_setHoldRadius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getHoldRadius", VALUEFUNC(_wrap_Grid2DPageStrategyData_getHoldRadius), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getLoadRadiusInCells", VALUEFUNC(_wrap_Grid2DPageStrategyData_getLoadRadiusInCells), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getHoldRadiusInCells", VALUEFUNC(_wrap_Grid2DPageStrategyData_getHoldRadiusInCells), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setCellRange", VALUEFUNC(_wrap_Grid2DPageStrategyData_setCellRange), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setCellRangeMinX", VALUEFUNC(_wrap_Grid2DPageStrategyData_setCellRangeMinX), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setCellRangeMinY", VALUEFUNC(_wrap_Grid2DPageStrategyData_setCellRangeMinY), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setCellRangeMaxX", VALUEFUNC(_wrap_Grid2DPageStrategyData_setCellRangeMaxX), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "setCellRangeMaxY", VALUEFUNC(_wrap_Grid2DPageStrategyData_setCellRangeMaxY), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getCellRangeMinX", VALUEFUNC(_wrap_Grid2DPageStrategyData_getCellRangeMinX), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getCellRangeMinY", VALUEFUNC(_wrap_Grid2DPageStrategyData_getCellRangeMinY), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getCellRangeMaxX", VALUEFUNC(_wrap_Grid2DPageStrategyData_getCellRangeMaxX), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getCellRangeMaxY", VALUEFUNC(_wrap_Grid2DPageStrategyData_getCellRangeMaxY), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "load", VALUEFUNC(_wrap_Grid2DPageStrategyData_load), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "save", VALUEFUNC(_wrap_Grid2DPageStrategyData_save), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "convertWorldToGridSpace", VALUEFUNC(_wrap_Grid2DPageStrategyData_convertWorldToGridSpace), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "convertGridToWorldSpace", VALUEFUNC(_wrap_Grid2DPageStrategyData_convertGridToWorldSpace), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getMidPointGridSpace", VALUEFUNC(_wrap_Grid2DPageStrategyData_getMidPointGridSpace), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getBottomLeftGridSpace", VALUEFUNC(_wrap_Grid2DPageStrategyData_getBottomLeftGridSpace), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "getCornersGridSpace", VALUEFUNC(_wrap_Grid2DPageStrategyData_getCornersGridSpace), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "determineGridLocation", VALUEFUNC(_wrap_Grid2DPageStrategyData_determineGridLocation), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "calculatePageID", VALUEFUNC(_wrap_Grid2DPageStrategyData_calculatePageID), -1);
  rb_define_method(SwigClassGrid2DPageStrategyData.klass, "calculateCell", VALUEFUNC(_wrap_Grid2DPageStrategyData_calculateCell), -1);
  SwigClassGrid2DPageStrategyData.mark = 0;
  SwigClassGrid2DPageStrategyData.destroy = (void (*)(void *)) free_Ogre_Grid2DPageStrategyData;
  SwigClassGrid2DPageStrategyData.trackObjects = 0;
  
  SwigClassGrid2DPageStrategy.klass = rb_define_class_under(mOgre, "Grid2DPageStrategy", ((swig_class *) SWIGTYPE_p_Ogre__PageStrategy->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Grid2DPageStrategy, (void *) &SwigClassGrid2DPageStrategy);
  rb_define_alloc_func(SwigClassGrid2DPageStrategy.klass, _wrap_Grid2DPageStrategy_allocate);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "initialize", VALUEFUNC(_wrap_new_Grid2DPageStrategy), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "notifyCamera", VALUEFUNC(_wrap_Grid2DPageStrategy_notifyCamera), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "createData", VALUEFUNC(_wrap_Grid2DPageStrategy_createData), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "destroyData", VALUEFUNC(_wrap_Grid2DPageStrategy_destroyData), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "updateDebugDisplay", VALUEFUNC(_wrap_Grid2DPageStrategy_updateDebugDisplay), -1);
  rb_define_method(SwigClassGrid2DPageStrategy.klass, "getPageID", VALUEFUNC(_wrap_Grid2DPageStrategy_getPageID), -1);
  SwigClassGrid2DPageStrategy.mark = 0;
  SwigClassGrid2DPageStrategy.destroy = (void (*)(void *)) free_Ogre_Grid2DPageStrategy;
  SwigClassGrid2DPageStrategy.trackObjects = 0;
  
  SwigClassGrid3DPageStrategyData.klass = rb_define_class_under(mOgre, "Grid3DPageStrategyData", ((swig_class *) SWIGTYPE_p_Ogre__PageStrategyData->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Grid3DPageStrategyData, (void *) &SwigClassGrid3DPageStrategyData);
  rb_define_alloc_func(SwigClassGrid3DPageStrategyData.klass, _wrap_Grid3DPageStrategyData_allocate);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "initialize", VALUEFUNC(_wrap_new_Grid3DPageStrategyData), -1);
  rb_define_singleton_method(SwigClassGrid3DPageStrategyData.klass, "CHUNK_ID", VALUEFUNC(_wrap_Grid3DPageStrategyData_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassGrid3DPageStrategyData.klass, "CHUNK_VERSION", VALUEFUNC(_wrap_Grid3DPageStrategyData_CHUNK_VERSION_get), 0);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setOrigin", VALUEFUNC(_wrap_Grid3DPageStrategyData_setOrigin), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getOrigin", VALUEFUNC(_wrap_Grid3DPageStrategyData_getOrigin), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellSize", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellSize), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCellSize", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCellSize), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setLoadRadius", VALUEFUNC(_wrap_Grid3DPageStrategyData_setLoadRadius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getLoadRadius", VALUEFUNC(_wrap_Grid3DPageStrategyData_getLoadRadius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setHoldRadius", VALUEFUNC(_wrap_Grid3DPageStrategyData_setHoldRadius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getHoldRadius", VALUEFUNC(_wrap_Grid3DPageStrategyData_getHoldRadius), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellRange", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellRange), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellRangeMinX", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellRangeMinX), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellRangeMinY", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellRangeMinY), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellRangeMinZ", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellRangeMinZ), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellRangeMaxX", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellRangeMaxX), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellRangeMaxY", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellRangeMaxY), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "setCellRangeMaxZ", VALUEFUNC(_wrap_Grid3DPageStrategyData_setCellRangeMaxZ), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCellRangeMinX", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCellRangeMinX), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCellRangeMinY", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCellRangeMinY), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCellRangeMinZ", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCellRangeMinZ), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCellRangeMaxX", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCellRangeMaxX), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCellRangeMaxY", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCellRangeMaxY), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCellRangeMaxZ", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCellRangeMaxZ), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "load", VALUEFUNC(_wrap_Grid3DPageStrategyData_load), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "save", VALUEFUNC(_wrap_Grid3DPageStrategyData_save), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getMidPointGridSpace", VALUEFUNC(_wrap_Grid3DPageStrategyData_getMidPointGridSpace), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getBottomLeftGridSpace", VALUEFUNC(_wrap_Grid3DPageStrategyData_getBottomLeftGridSpace), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "getCornersGridSpace", VALUEFUNC(_wrap_Grid3DPageStrategyData_getCornersGridSpace), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "determineGridLocation", VALUEFUNC(_wrap_Grid3DPageStrategyData_determineGridLocation), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "calculatePageID", VALUEFUNC(_wrap_Grid3DPageStrategyData_calculatePageID), -1);
  rb_define_method(SwigClassGrid3DPageStrategyData.klass, "calculateCell", VALUEFUNC(_wrap_Grid3DPageStrategyData_calculateCell), -1);
  SwigClassGrid3DPageStrategyData.mark = 0;
  SwigClassGrid3DPageStrategyData.destroy = (void (*)(void *)) free_Ogre_Grid3DPageStrategyData;
  SwigClassGrid3DPageStrategyData.trackObjects = 0;
  
  SwigClassGrid3DPageStrategy.klass = rb_define_class_under(mOgre, "Grid3DPageStrategy", ((swig_class *) SWIGTYPE_p_Ogre__PageStrategy->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Grid3DPageStrategy, (void *) &SwigClassGrid3DPageStrategy);
  rb_define_alloc_func(SwigClassGrid3DPageStrategy.klass, _wrap_Grid3DPageStrategy_allocate);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "initialize", VALUEFUNC(_wrap_new_Grid3DPageStrategy), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "notifyCamera", VALUEFUNC(_wrap_Grid3DPageStrategy_notifyCamera), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "createData", VALUEFUNC(_wrap_Grid3DPageStrategy_createData), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "destroyData", VALUEFUNC(_wrap_Grid3DPageStrategy_destroyData), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "updateDebugDisplay", VALUEFUNC(_wrap_Grid3DPageStrategy_updateDebugDisplay), -1);
  rb_define_method(SwigClassGrid3DPageStrategy.klass, "getPageID", VALUEFUNC(_wrap_Grid3DPageStrategy_getPageID), -1);
  SwigClassGrid3DPageStrategy.mark = 0;
  SwigClassGrid3DPageStrategy.destroy = (void (*)(void *)) free_Ogre_Grid3DPageStrategy;
  SwigClassGrid3DPageStrategy.trackObjects = 0;
  
  SwigClassPage.klass = rb_define_class_under(mOgre, "Page", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Page, (void *) &SwigClassPage);
  rb_define_alloc_func(SwigClassPage.klass, _wrap_Page_allocate);
  rb_define_method(SwigClassPage.klass, "initialize", VALUEFUNC(_wrap_new_Page), -1);
  rb_define_singleton_method(SwigClassPage.klass, "CHUNK_ID", VALUEFUNC(_wrap_Page_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassPage.klass, "CHUNK_VERSION", VALUEFUNC(_wrap_Page_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassPage.klass, "CHUNK_CONTENTCOLLECTION_DECLARATION_ID", VALUEFUNC(_wrap_Page_CHUNK_CONTENTCOLLECTION_DECLARATION_ID_get), 0);
  rb_define_method(SwigClassPage.klass, "getManager", VALUEFUNC(_wrap_Page_getManager), -1);
  rb_define_method(SwigClassPage.klass, "getSceneManager", VALUEFUNC(_wrap_Page_getSceneManager), -1);
  rb_define_method(SwigClassPage.klass, "isDeferredProcessInProgress", VALUEFUNC(_wrap_Page_isDeferredProcessInProgress), -1);
  rb_define_method(SwigClassPage.klass, "getID", VALUEFUNC(_wrap_Page_getID), -1);
  rb_define_method(SwigClassPage.klass, "getParentSection", VALUEFUNC(_wrap_Page_getParentSection), -1);
  rb_define_method(SwigClassPage.klass, "getFrameLastHeld", VALUEFUNC(_wrap_Page_getFrameLastHeld), -1);
  rb_define_method(SwigClassPage.klass, "touch", VALUEFUNC(_wrap_Page_touch), -1);
  rb_define_method(SwigClassPage.klass, "load", VALUEFUNC(_wrap_Page_load), -1);
  rb_define_method(SwigClassPage.klass, "unload", VALUEFUNC(_wrap_Page_unload), -1);
  rb_define_method(SwigClassPage.klass, "isHeld", VALUEFUNC(_wrap_Page_isHeld), -1);
  rb_define_method(SwigClassPage.klass, "save", VALUEFUNC(_wrap_Page_save), -1);
  rb_define_method(SwigClassPage.klass, "frameStart", VALUEFUNC(_wrap_Page_frameStart), -1);
  rb_define_method(SwigClassPage.klass, "frameEnd", VALUEFUNC(_wrap_Page_frameEnd), -1);
  rb_define_method(SwigClassPage.klass, "notifyCamera", VALUEFUNC(_wrap_Page_notifyCamera), -1);
  rb_define_method(SwigClassPage.klass, "createContentCollection", VALUEFUNC(_wrap_Page_createContentCollection), -1);
  rb_define_method(SwigClassPage.klass, "destroyContentCollection", VALUEFUNC(_wrap_Page_destroyContentCollection), -1);
  rb_define_method(SwigClassPage.klass, "destroyAllContentCollections", VALUEFUNC(_wrap_Page_destroyAllContentCollections), -1);
  rb_define_method(SwigClassPage.klass, "getContentCollectionCount", VALUEFUNC(_wrap_Page_getContentCollectionCount), -1);
  rb_define_method(SwigClassPage.klass, "getContentCollection", VALUEFUNC(_wrap_Page_getContentCollection), -1);
  rb_define_method(SwigClassPage.klass, "getContentCollectionList", VALUEFUNC(_wrap_Page_getContentCollectionList), -1);
  rb_define_method(SwigClassPage.klass, "canHandleRequest", VALUEFUNC(_wrap_Page_canHandleRequest), -1);
  rb_define_method(SwigClassPage.klass, "handleRequest", VALUEFUNC(_wrap_Page_handleRequest), -1);
  rb_define_method(SwigClassPage.klass, "canHandleResponse", VALUEFUNC(_wrap_Page_canHandleResponse), -1);
  rb_define_method(SwigClassPage.klass, "handleResponse", VALUEFUNC(_wrap_Page_handleResponse), -1);
  rb_define_method(SwigClassPage.klass, "_notifyModified", VALUEFUNC(_wrap_Page__notifyModified), -1);
  rb_define_method(SwigClassPage.klass, "isModified", VALUEFUNC(_wrap_Page_isModified), -1);
  rb_define_singleton_method(SwigClassPage.klass, "WORKQUEUE_PREPARE_REQUEST", VALUEFUNC(_wrap_Page_WORKQUEUE_PREPARE_REQUEST_get), 0);
  rb_define_singleton_method(SwigClassPage.klass, "WORKQUEUE_CHANGECOLLECTION_REQUEST", VALUEFUNC(_wrap_Page_WORKQUEUE_CHANGECOLLECTION_REQUEST_get), 0);
  SwigClassPage.mark = 0;
  SwigClassPage.destroy = (void (*)(void *)) free_Ogre_Page;
  SwigClassPage.trackObjects = 0;
  
  SwigClassPageContent.klass = rb_define_class_under(mOgre, "PageContent", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageContent, (void *) &SwigClassPageContent);
  rb_undef_alloc_func(SwigClassPageContent.klass);
  rb_define_method(SwigClassPageContent.klass, "getManager", VALUEFUNC(_wrap_PageContent_getManager), -1);
  rb_define_method(SwigClassPageContent.klass, "getSceneManager", VALUEFUNC(_wrap_PageContent_getSceneManager), -1);
  rb_define_method(SwigClassPageContent.klass, "_notifyAttached", VALUEFUNC(_wrap_PageContent__notifyAttached), -1);
  rb_define_method(SwigClassPageContent.klass, "getType", VALUEFUNC(_wrap_PageContent_getType), -1);
  rb_define_method(SwigClassPageContent.klass, "save", VALUEFUNC(_wrap_PageContent_save), -1);
  rb_define_method(SwigClassPageContent.klass, "frameStart", VALUEFUNC(_wrap_PageContent_frameStart), -1);
  rb_define_method(SwigClassPageContent.klass, "frameEnd", VALUEFUNC(_wrap_PageContent_frameEnd), -1);
  rb_define_method(SwigClassPageContent.klass, "notifyCamera", VALUEFUNC(_wrap_PageContent_notifyCamera), -1);
  rb_define_method(SwigClassPageContent.klass, "prepare", VALUEFUNC(_wrap_PageContent_prepare), -1);
  rb_define_method(SwigClassPageContent.klass, "load", VALUEFUNC(_wrap_PageContent_load), -1);
  rb_define_method(SwigClassPageContent.klass, "unload", VALUEFUNC(_wrap_PageContent_unload), -1);
  rb_define_method(SwigClassPageContent.klass, "unprepare", VALUEFUNC(_wrap_PageContent_unprepare), -1);
  SwigClassPageContent.mark = 0;
  SwigClassPageContent.destroy = (void (*)(void *)) free_Ogre_PageContent;
  SwigClassPageContent.trackObjects = 0;
  
  SwigClassPageContentCollection.klass = rb_define_class_under(mOgre, "PageContentCollection", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageContentCollection, (void *) &SwigClassPageContentCollection);
  rb_undef_alloc_func(SwigClassPageContentCollection.klass);
  rb_define_singleton_method(SwigClassPageContentCollection.klass, "CHUNK_ID", VALUEFUNC(_wrap_PageContentCollection_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassPageContentCollection.klass, "CHUNK_VERSION", VALUEFUNC(_wrap_PageContentCollection_CHUNK_VERSION_get), 0);
  rb_define_method(SwigClassPageContentCollection.klass, "getManager", VALUEFUNC(_wrap_PageContentCollection_getManager), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "getParentPage", VALUEFUNC(_wrap_PageContentCollection_getParentPage), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "getSceneManager", VALUEFUNC(_wrap_PageContentCollection_getSceneManager), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "getType", VALUEFUNC(_wrap_PageContentCollection_getType), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "_notifyAttached", VALUEFUNC(_wrap_PageContentCollection__notifyAttached), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "save", VALUEFUNC(_wrap_PageContentCollection_save), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "frameStart", VALUEFUNC(_wrap_PageContentCollection_frameStart), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "frameEnd", VALUEFUNC(_wrap_PageContentCollection_frameEnd), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "notifyCamera", VALUEFUNC(_wrap_PageContentCollection_notifyCamera), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "prepare", VALUEFUNC(_wrap_PageContentCollection_prepare), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "load", VALUEFUNC(_wrap_PageContentCollection_load), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "unload", VALUEFUNC(_wrap_PageContentCollection_unload), -1);
  rb_define_method(SwigClassPageContentCollection.klass, "unprepare", VALUEFUNC(_wrap_PageContentCollection_unprepare), -1);
  SwigClassPageContentCollection.mark = 0;
  SwigClassPageContentCollection.destroy = (void (*)(void *)) free_Ogre_PageContentCollection;
  SwigClassPageContentCollection.trackObjects = 0;
  
  SwigClassPageContentCollectionFactory.klass = rb_define_class_under(mOgre, "PageContentCollectionFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageContentCollectionFactory, (void *) &SwigClassPageContentCollectionFactory);
  rb_undef_alloc_func(SwigClassPageContentCollectionFactory.klass);
  rb_define_method(SwigClassPageContentCollectionFactory.klass, "getName", VALUEFUNC(_wrap_PageContentCollectionFactory_getName), -1);
  rb_define_method(SwigClassPageContentCollectionFactory.klass, "createInstance", VALUEFUNC(_wrap_PageContentCollectionFactory_createInstance), -1);
  rb_define_method(SwigClassPageContentCollectionFactory.klass, "destroyInstance", VALUEFUNC(_wrap_PageContentCollectionFactory_destroyInstance), -1);
  SwigClassPageContentCollectionFactory.mark = 0;
  SwigClassPageContentCollectionFactory.destroy = (void (*)(void *)) free_Ogre_PageContentCollectionFactory;
  SwigClassPageContentCollectionFactory.trackObjects = 0;
  
  SwigClassPageContentFactory.klass = rb_define_class_under(mOgre, "PageContentFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageContentFactory, (void *) &SwigClassPageContentFactory);
  rb_undef_alloc_func(SwigClassPageContentFactory.klass);
  rb_define_method(SwigClassPageContentFactory.klass, "getName", VALUEFUNC(_wrap_PageContentFactory_getName), -1);
  rb_define_method(SwigClassPageContentFactory.klass, "createInstance", VALUEFUNC(_wrap_PageContentFactory_createInstance), -1);
  rb_define_method(SwigClassPageContentFactory.klass, "destroyInstance", VALUEFUNC(_wrap_PageContentFactory_destroyInstance), -1);
  SwigClassPageContentFactory.mark = 0;
  SwigClassPageContentFactory.destroy = (void (*)(void *)) free_Ogre_PageContentFactory;
  SwigClassPageContentFactory.trackObjects = 0;
  
  SwigClassPageProvider.klass = rb_define_class_under(mOgre, "PageProvider", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageProvider, (void *) &SwigClassPageProvider);
  rb_define_alloc_func(SwigClassPageProvider.klass, _wrap_PageProvider_allocate);
  rb_define_method(SwigClassPageProvider.klass, "initialize", VALUEFUNC(_wrap_new_PageProvider), -1);
  rb_define_method(SwigClassPageProvider.klass, "prepareProceduralPage", VALUEFUNC(_wrap_PageProvider_prepareProceduralPage), -1);
  rb_define_method(SwigClassPageProvider.klass, "loadProceduralPage", VALUEFUNC(_wrap_PageProvider_loadProceduralPage), -1);
  rb_define_method(SwigClassPageProvider.klass, "unloadProceduralPage", VALUEFUNC(_wrap_PageProvider_unloadProceduralPage), -1);
  rb_define_method(SwigClassPageProvider.klass, "unprepareProceduralPage", VALUEFUNC(_wrap_PageProvider_unprepareProceduralPage), -1);
  rb_define_method(SwigClassPageProvider.klass, "readWorldStream", VALUEFUNC(_wrap_PageProvider_readWorldStream), -1);
  rb_define_method(SwigClassPageProvider.klass, "writeWorldStream", VALUEFUNC(_wrap_PageProvider_writeWorldStream), -1);
  rb_define_method(SwigClassPageProvider.klass, "readPageStream", VALUEFUNC(_wrap_PageProvider_readPageStream), -1);
  rb_define_method(SwigClassPageProvider.klass, "writePageStream", VALUEFUNC(_wrap_PageProvider_writePageStream), -1);
  SwigClassPageProvider.mark = 0;
  SwigClassPageProvider.destroy = (void (*)(void *)) free_Ogre_PageProvider;
  SwigClassPageProvider.trackObjects = 0;
  
  SwigClassPageManager.klass = rb_define_class_under(mOgre, "PageManager", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PageManager, (void *) &SwigClassPageManager);
  rb_define_alloc_func(SwigClassPageManager.klass, _wrap_PageManager_allocate);
  rb_define_method(SwigClassPageManager.klass, "initialize", VALUEFUNC(_wrap_new_PageManager), -1);
  rb_define_method(SwigClassPageManager.klass, "createWorld", VALUEFUNC(_wrap_PageManager_createWorld), -1);
  rb_define_method(SwigClassPageManager.klass, "destroyWorld", VALUEFUNC(_wrap_PageManager_destroyWorld), -1);
  rb_define_method(SwigClassPageManager.klass, "loadWorld", VALUEFUNC(_wrap_PageManager_loadWorld), -1);
  rb_define_method(SwigClassPageManager.klass, "saveWorld", VALUEFUNC(_wrap_PageManager_saveWorld), -1);
  rb_define_method(SwigClassPageManager.klass, "getWorld", VALUEFUNC(_wrap_PageManager_getWorld), -1);
  rb_define_method(SwigClassPageManager.klass, "getWorlds", VALUEFUNC(_wrap_PageManager_getWorlds), -1);
  rb_define_method(SwigClassPageManager.klass, "addStrategy", VALUEFUNC(_wrap_PageManager_addStrategy), -1);
  rb_define_method(SwigClassPageManager.klass, "removeStrategy", VALUEFUNC(_wrap_PageManager_removeStrategy), -1);
  rb_define_method(SwigClassPageManager.klass, "getStrategy", VALUEFUNC(_wrap_PageManager_getStrategy), -1);
  rb_define_method(SwigClassPageManager.klass, "getStrategies", VALUEFUNC(_wrap_PageManager_getStrategies), -1);
  rb_define_method(SwigClassPageManager.klass, "addContentCollectionFactory", VALUEFUNC(_wrap_PageManager_addContentCollectionFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "removeContentCollectionFactory", VALUEFUNC(_wrap_PageManager_removeContentCollectionFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "getContentCollectionFactory", VALUEFUNC(_wrap_PageManager_getContentCollectionFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "createContentCollection", VALUEFUNC(_wrap_PageManager_createContentCollection), -1);
  rb_define_method(SwigClassPageManager.klass, "destroyContentCollection", VALUEFUNC(_wrap_PageManager_destroyContentCollection), -1);
  rb_define_method(SwigClassPageManager.klass, "getContentCollectionFactories", VALUEFUNC(_wrap_PageManager_getContentCollectionFactories), -1);
  rb_define_method(SwigClassPageManager.klass, "addContentFactory", VALUEFUNC(_wrap_PageManager_addContentFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "removeContentFactory", VALUEFUNC(_wrap_PageManager_removeContentFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "getContentFactory", VALUEFUNC(_wrap_PageManager_getContentFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "getContentFactories", VALUEFUNC(_wrap_PageManager_getContentFactories), -1);
  rb_define_method(SwigClassPageManager.klass, "createContent", VALUEFUNC(_wrap_PageManager_createContent), -1);
  rb_define_method(SwigClassPageManager.klass, "destroyContent", VALUEFUNC(_wrap_PageManager_destroyContent), -1);
  rb_define_method(SwigClassPageManager.klass, "addWorldSectionFactory", VALUEFUNC(_wrap_PageManager_addWorldSectionFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "removeWorldSectionFactory", VALUEFUNC(_wrap_PageManager_removeWorldSectionFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "getWorldSectionFactory", VALUEFUNC(_wrap_PageManager_getWorldSectionFactory), -1);
  rb_define_method(SwigClassPageManager.klass, "createWorldSection", VALUEFUNC(_wrap_PageManager_createWorldSection), -1);
  rb_define_method(SwigClassPageManager.klass, "destroyWorldSection", VALUEFUNC(_wrap_PageManager_destroyWorldSection), -1);
  rb_define_method(SwigClassPageManager.klass, "getWorldSectionFactories", VALUEFUNC(_wrap_PageManager_getWorldSectionFactories), -1);
  rb_define_method(SwigClassPageManager.klass, "setPageProvider", VALUEFUNC(_wrap_PageManager_setPageProvider), -1);
  rb_define_method(SwigClassPageManager.klass, "getPageProvider", VALUEFUNC(_wrap_PageManager_getPageProvider), -1);
  rb_define_method(SwigClassPageManager.klass, "_prepareProceduralPage", VALUEFUNC(_wrap_PageManager__prepareProceduralPage), -1);
  rb_define_method(SwigClassPageManager.klass, "_loadProceduralPage", VALUEFUNC(_wrap_PageManager__loadProceduralPage), -1);
  rb_define_method(SwigClassPageManager.klass, "_unloadProceduralPage", VALUEFUNC(_wrap_PageManager__unloadProceduralPage), -1);
  rb_define_method(SwigClassPageManager.klass, "_unprepareProceduralPage", VALUEFUNC(_wrap_PageManager__unprepareProceduralPage), -1);
  rb_define_method(SwigClassPageManager.klass, "_readPageStream", VALUEFUNC(_wrap_PageManager__readPageStream), -1);
  rb_define_method(SwigClassPageManager.klass, "_writePageStream", VALUEFUNC(_wrap_PageManager__writePageStream), -1);
  rb_define_method(SwigClassPageManager.klass, "_readWorldStream", VALUEFUNC(_wrap_PageManager__readWorldStream), -1);
  rb_define_method(SwigClassPageManager.klass, "_writeWorldStream", VALUEFUNC(_wrap_PageManager__writeWorldStream), -1);
  rb_define_method(SwigClassPageManager.klass, "getPageResourceGroup", VALUEFUNC(_wrap_PageManager_getPageResourceGroup), -1);
  rb_define_method(SwigClassPageManager.klass, "setPageResourceGroup", VALUEFUNC(_wrap_PageManager_setPageResourceGroup), -1);
  rb_define_method(SwigClassPageManager.klass, "addCamera", VALUEFUNC(_wrap_PageManager_addCamera), -1);
  rb_define_method(SwigClassPageManager.klass, "removeCamera", VALUEFUNC(_wrap_PageManager_removeCamera), -1);
  rb_define_method(SwigClassPageManager.klass, "hasCamera", VALUEFUNC(_wrap_PageManager_hasCamera), -1);
  rb_define_method(SwigClassPageManager.klass, "getCameraList", VALUEFUNC(_wrap_PageManager_getCameraList), -1);
  rb_define_method(SwigClassPageManager.klass, "setDebugDisplayLevel", VALUEFUNC(_wrap_PageManager_setDebugDisplayLevel), -1);
  rb_define_method(SwigClassPageManager.klass, "getDebugDisplayLevel", VALUEFUNC(_wrap_PageManager_getDebugDisplayLevel), -1);
  rb_define_method(SwigClassPageManager.klass, "setPagingOperationsEnabled", VALUEFUNC(_wrap_PageManager_setPagingOperationsEnabled), -1);
  rb_define_method(SwigClassPageManager.klass, "getPagingOperationsEnabled", VALUEFUNC(_wrap_PageManager_getPagingOperationsEnabled), -1);
  SwigClassPageManager.mark = 0;
  SwigClassPageManager.destroy = (void (*)(void *)) free_Ogre_PageManager;
  SwigClassPageManager.trackObjects = 0;
  
  SwigClassPagedWorld.klass = rb_define_class_under(mOgre, "PagedWorld", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PagedWorld, (void *) &SwigClassPagedWorld);
  rb_define_alloc_func(SwigClassPagedWorld.klass, _wrap_PagedWorld_allocate);
  rb_define_method(SwigClassPagedWorld.klass, "initialize", VALUEFUNC(_wrap_new_PagedWorld), -1);
  rb_define_singleton_method(SwigClassPagedWorld.klass, "CHUNK_ID", VALUEFUNC(_wrap_PagedWorld_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassPagedWorld.klass, "CHUNK_VERSION", VALUEFUNC(_wrap_PagedWorld_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassPagedWorld.klass, "CHUNK_SECTIONDECLARATION_ID", VALUEFUNC(_wrap_PagedWorld_CHUNK_SECTIONDECLARATION_ID_get), 0);
  rb_define_method(SwigClassPagedWorld.klass, "getName", VALUEFUNC(_wrap_PagedWorld_getName), -1);
  rb_define_method(SwigClassPagedWorld.klass, "getManager", VALUEFUNC(_wrap_PagedWorld_getManager), -1);
  rb_define_method(SwigClassPagedWorld.klass, "load", VALUEFUNC(_wrap_PagedWorld_load), -1);
  rb_define_method(SwigClassPagedWorld.klass, "save", VALUEFUNC(_wrap_PagedWorld_save), -1);
  rb_define_method(SwigClassPagedWorld.klass, "createSection", VALUEFUNC(_wrap_PagedWorld_createSection), -1);
  rb_define_method(SwigClassPagedWorld.klass, "destroySection", VALUEFUNC(_wrap_PagedWorld_destroySection), -1);
  rb_define_method(SwigClassPagedWorld.klass, "destroyAllSections", VALUEFUNC(_wrap_PagedWorld_destroyAllSections), -1);
  rb_define_method(SwigClassPagedWorld.klass, "getSectionCount", VALUEFUNC(_wrap_PagedWorld_getSectionCount), -1);
  rb_define_method(SwigClassPagedWorld.klass, "getSection", VALUEFUNC(_wrap_PagedWorld_getSection), -1);
  rb_define_method(SwigClassPagedWorld.klass, "getSections", VALUEFUNC(_wrap_PagedWorld_getSections), -1);
  rb_define_method(SwigClassPagedWorld.klass, "setPageProvider", VALUEFUNC(_wrap_PagedWorld_setPageProvider), -1);
  rb_define_method(SwigClassPagedWorld.klass, "getPageProvider", VALUEFUNC(_wrap_PagedWorld_getPageProvider), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_prepareProceduralPage", VALUEFUNC(_wrap_PagedWorld__prepareProceduralPage), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_loadProceduralPage", VALUEFUNC(_wrap_PagedWorld__loadProceduralPage), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_unloadProceduralPage", VALUEFUNC(_wrap_PagedWorld__unloadProceduralPage), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_unprepareProceduralPage", VALUEFUNC(_wrap_PagedWorld__unprepareProceduralPage), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_readPageStream", VALUEFUNC(_wrap_PagedWorld__readPageStream), -1);
  rb_define_method(SwigClassPagedWorld.klass, "_writePageStream", VALUEFUNC(_wrap_PagedWorld__writePageStream), -1);
  rb_define_method(SwigClassPagedWorld.klass, "frameStart", VALUEFUNC(_wrap_PagedWorld_frameStart), -1);
  rb_define_method(SwigClassPagedWorld.klass, "frameEnd", VALUEFUNC(_wrap_PagedWorld_frameEnd), -1);
  rb_define_method(SwigClassPagedWorld.klass, "notifyCamera", VALUEFUNC(_wrap_PagedWorld_notifyCamera), -1);
  SwigClassPagedWorld.mark = 0;
  SwigClassPagedWorld.destroy = (void (*)(void *)) free_Ogre_PagedWorld;
  SwigClassPagedWorld.trackObjects = 0;
  
  SwigClassPagedWorldSection.klass = rb_define_class_under(mOgre, "PagedWorldSection", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PagedWorldSection, (void *) &SwigClassPagedWorldSection);
  rb_define_alloc_func(SwigClassPagedWorldSection.klass, _wrap_PagedWorldSection_allocate);
  rb_define_method(SwigClassPagedWorldSection.klass, "initialize", VALUEFUNC(_wrap_new_PagedWorldSection), -1);
  rb_define_singleton_method(SwigClassPagedWorldSection.klass, "CHUNK_ID", VALUEFUNC(_wrap_PagedWorldSection_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassPagedWorldSection.klass, "CHUNK_VERSION", VALUEFUNC(_wrap_PagedWorldSection_CHUNK_VERSION_get), 0);
  rb_define_method(SwigClassPagedWorldSection.klass, "getManager", VALUEFUNC(_wrap_PagedWorldSection_getManager), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getName", VALUEFUNC(_wrap_PagedWorldSection_getName), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getStrategy", VALUEFUNC(_wrap_PagedWorldSection_getStrategy), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "setStrategy", VALUEFUNC(_wrap_PagedWorldSection_setStrategy), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "setSceneManager", VALUEFUNC(_wrap_PagedWorldSection_setSceneManager), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getSceneManager", VALUEFUNC(_wrap_PagedWorldSection_getSceneManager), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getWorld", VALUEFUNC(_wrap_PagedWorldSection_getWorld), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getStrategyData", VALUEFUNC(_wrap_PagedWorldSection_getStrategyData), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "setBoundingBox", VALUEFUNC(_wrap_PagedWorldSection_setBoundingBox), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getBoundingBox", VALUEFUNC(_wrap_PagedWorldSection_getBoundingBox), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "load", VALUEFUNC(_wrap_PagedWorldSection_load), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "save", VALUEFUNC(_wrap_PagedWorldSection_save), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "frameStart", VALUEFUNC(_wrap_PagedWorldSection_frameStart), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "frameEnd", VALUEFUNC(_wrap_PagedWorldSection_frameEnd), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "notifyCamera", VALUEFUNC(_wrap_PagedWorldSection_notifyCamera), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "loadOrCreatePage", VALUEFUNC(_wrap_PagedWorldSection_loadOrCreatePage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getPageID", VALUEFUNC(_wrap_PagedWorldSection_getPageID), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "loadPage", VALUEFUNC(_wrap_PagedWorldSection_loadPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "unloadPage", VALUEFUNC(_wrap_PagedWorldSection_unloadPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_prepareProceduralPage", VALUEFUNC(_wrap_PagedWorldSection__prepareProceduralPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_loadProceduralPage", VALUEFUNC(_wrap_PagedWorldSection__loadProceduralPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_unloadProceduralPage", VALUEFUNC(_wrap_PagedWorldSection__unloadProceduralPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_unprepareProceduralPage", VALUEFUNC(_wrap_PagedWorldSection__unprepareProceduralPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "holdPage", VALUEFUNC(_wrap_PagedWorldSection_holdPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getPage", VALUEFUNC(_wrap_PagedWorldSection_getPage), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "removeAllPages", VALUEFUNC(_wrap_PagedWorldSection_removeAllPages), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "setPageProvider", VALUEFUNC(_wrap_PagedWorldSection_setPageProvider), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getPageProvider", VALUEFUNC(_wrap_PagedWorldSection_getPageProvider), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_readPageStream", VALUEFUNC(_wrap_PagedWorldSection__readPageStream), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "_writePageStream", VALUEFUNC(_wrap_PagedWorldSection__writePageStream), -1);
  rb_define_method(SwigClassPagedWorldSection.klass, "getType", VALUEFUNC(_wrap_PagedWorldSection_getType), -1);
  SwigClassPagedWorldSection.mark = 0;
  SwigClassPagedWorldSection.destroy = (void (*)(void *)) free_Ogre_PagedWorldSection;
  SwigClassPagedWorldSection.trackObjects = 0;
  
  SwigClassPagedWorldSectionFactory.klass = rb_define_class_under(mOgre, "PagedWorldSectionFactory", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__PagedWorldSectionFactory, (void *) &SwigClassPagedWorldSectionFactory);
  rb_undef_alloc_func(SwigClassPagedWorldSectionFactory.klass);
  rb_define_method(SwigClassPagedWorldSectionFactory.klass, "getName", VALUEFUNC(_wrap_PagedWorldSectionFactory_getName), -1);
  rb_define_method(SwigClassPagedWorldSectionFactory.klass, "createInstance", VALUEFUNC(_wrap_PagedWorldSectionFactory_createInstance), -1);
  rb_define_method(SwigClassPagedWorldSectionFactory.klass, "destroyInstance", VALUEFUNC(_wrap_PagedWorldSectionFactory_destroyInstance), -1);
  SwigClassPagedWorldSectionFactory.mark = 0;
  SwigClassPagedWorldSectionFactory.destroy = (void (*)(void *)) free_Ogre_PagedWorldSectionFactory;
  SwigClassPagedWorldSectionFactory.trackObjects = 0;
  
  SwigClassSimplePageContentCollection.klass = rb_define_class_under(mOgre, "SimplePageContentCollection", ((swig_class *) SWIGTYPE_p_Ogre__PageContentCollection->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SimplePageContentCollection, (void *) &SwigClassSimplePageContentCollection);
  rb_define_alloc_func(SwigClassSimplePageContentCollection.klass, _wrap_SimplePageContentCollection_allocate);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "initialize", VALUEFUNC(_wrap_new_SimplePageContentCollection), -1);
  rb_define_singleton_method(SwigClassSimplePageContentCollection.klass, "SUBCLASS_CHUNK_ID", VALUEFUNC(_wrap_SimplePageContentCollection_SUBCLASS_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassSimplePageContentCollection.klass, "SUBCLASS_CHUNK_VERSION", VALUEFUNC(_wrap_SimplePageContentCollection_SUBCLASS_CHUNK_VERSION_get), 0);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "createContent", VALUEFUNC(_wrap_SimplePageContentCollection_createContent), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "destroyContent", VALUEFUNC(_wrap_SimplePageContentCollection_destroyContent), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "getContentList", VALUEFUNC(_wrap_SimplePageContentCollection_getContentList), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "save", VALUEFUNC(_wrap_SimplePageContentCollection_save), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "frameStart", VALUEFUNC(_wrap_SimplePageContentCollection_frameStart), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "frameEnd", VALUEFUNC(_wrap_SimplePageContentCollection_frameEnd), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "notifyCamera", VALUEFUNC(_wrap_SimplePageContentCollection_notifyCamera), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "prepare", VALUEFUNC(_wrap_SimplePageContentCollection_prepare), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "load", VALUEFUNC(_wrap_SimplePageContentCollection_load), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "unload", VALUEFUNC(_wrap_SimplePageContentCollection_unload), -1);
  rb_define_method(SwigClassSimplePageContentCollection.klass, "unprepare", VALUEFUNC(_wrap_SimplePageContentCollection_unprepare), -1);
  SwigClassSimplePageContentCollection.mark = 0;
  SwigClassSimplePageContentCollection.destroy = (void (*)(void *)) free_Ogre_SimplePageContentCollection;
  SwigClassSimplePageContentCollection.trackObjects = 0;
  
  SwigClassSimplePageContentCollectionFactory.klass = rb_define_class_under(mOgre, "SimplePageContentCollectionFactory", ((swig_class *) SWIGTYPE_p_Ogre__PageContentCollectionFactory->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__SimplePageContentCollectionFactory, (void *) &SwigClassSimplePageContentCollectionFactory);
  rb_define_alloc_func(SwigClassSimplePageContentCollectionFactory.klass, _wrap_SimplePageContentCollectionFactory_allocate);
  rb_define_method(SwigClassSimplePageContentCollectionFactory.klass, "initialize", VALUEFUNC(_wrap_new_SimplePageContentCollectionFactory), -1);
  rb_define_singleton_method(SwigClassSimplePageContentCollectionFactory.klass, "FACTORY_NAME", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_FACTORY_NAME_get), 0);
  rb_define_singleton_method(SwigClassSimplePageContentCollectionFactory.klass, "FACTORY_NAME=", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_FACTORY_NAME_set), 1);
  rb_define_method(SwigClassSimplePageContentCollectionFactory.klass, "getName", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_getName), -1);
  rb_define_method(SwigClassSimplePageContentCollectionFactory.klass, "createInstance", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_createInstance), -1);
  rb_define_method(SwigClassSimplePageContentCollectionFactory.klass, "destroyInstance", VALUEFUNC(_wrap_SimplePageContentCollectionFactory_destroyInstance), -1);
  SwigClassSimplePageContentCollectionFactory.mark = 0;
  SwigClassSimplePageContentCollectionFactory.destroy = (void (*)(void *)) free_Ogre_SimplePageContentCollectionFactory;
  SwigClassSimplePageContentCollectionFactory.trackObjects = 0;
  
  SwigClassTerrainGroup.klass = rb_define_class_under(mOgre, "TerrainGroup", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainGroup, (void *) &SwigClassTerrainGroup);
  rb_define_alloc_func(SwigClassTerrainGroup.klass, _wrap_TerrainGroup_allocate);
  rb_define_method(SwigClassTerrainGroup.klass, "initialize", VALUEFUNC(_wrap_new_TerrainGroup), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getDefaultImportSettings", VALUEFUNC(_wrap_TerrainGroup_getDefaultImportSettings), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "setOrigin", VALUEFUNC(_wrap_TerrainGroup_setOrigin), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getOrigin", VALUEFUNC(_wrap_TerrainGroup_getOrigin), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getAlignment", VALUEFUNC(_wrap_TerrainGroup_getAlignment), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getTerrainWorldSize", VALUEFUNC(_wrap_TerrainGroup_getTerrainWorldSize), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "setTerrainWorldSize", VALUEFUNC(_wrap_TerrainGroup_setTerrainWorldSize), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getTerrainSize", VALUEFUNC(_wrap_TerrainGroup_getTerrainSize), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "setTerrainSize", VALUEFUNC(_wrap_TerrainGroup_setTerrainSize), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getSceneManager", VALUEFUNC(_wrap_TerrainGroup_getSceneManager), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "setFilenameConvention", VALUEFUNC(_wrap_TerrainGroup_setFilenameConvention), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "setFilenamePrefix", VALUEFUNC(_wrap_TerrainGroup_setFilenamePrefix), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "setFilenameExtension", VALUEFUNC(_wrap_TerrainGroup_setFilenameExtension), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getFilenamePrefix", VALUEFUNC(_wrap_TerrainGroup_getFilenamePrefix), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getFilenameExtension", VALUEFUNC(_wrap_TerrainGroup_getFilenameExtension), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "setResourceGroup", VALUEFUNC(_wrap_TerrainGroup_setResourceGroup), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getResourceGroup", VALUEFUNC(_wrap_TerrainGroup_getResourceGroup), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "defineTerrain", VALUEFUNC(_wrap_TerrainGroup_defineTerrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "loadAllTerrains", VALUEFUNC(_wrap_TerrainGroup_loadAllTerrains), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "loadTerrain", VALUEFUNC(_wrap_TerrainGroup_loadTerrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "unloadTerrain", VALUEFUNC(_wrap_TerrainGroup_unloadTerrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "removeTerrain", VALUEFUNC(_wrap_TerrainGroup_removeTerrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "removeAllTerrains", VALUEFUNC(_wrap_TerrainGroup_removeAllTerrains), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "saveAllTerrains", VALUEFUNC(_wrap_TerrainGroup_saveAllTerrains), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getTerrainDefinition", VALUEFUNC(_wrap_TerrainGroup_getTerrainDefinition), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getTerrain", VALUEFUNC(_wrap_TerrainGroup_getTerrain), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "freeTemporaryResources", VALUEFUNC(_wrap_TerrainGroup_freeTemporaryResources), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "update", VALUEFUNC(_wrap_TerrainGroup_update), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "updateGeometry", VALUEFUNC(_wrap_TerrainGroup_updateGeometry), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "updateDerivedData", VALUEFUNC(_wrap_TerrainGroup_updateDerivedData), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getHeightAtWorldPosition", VALUEFUNC(_wrap_TerrainGroup_getHeightAtWorldPosition), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "rayIntersects", VALUEFUNC(_wrap_TerrainGroup_rayIntersects), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "boxIntersects", VALUEFUNC(_wrap_TerrainGroup_boxIntersects), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "sphereIntersects", VALUEFUNC(_wrap_TerrainGroup_sphereIntersects), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "convertWorldPositionToTerrainSlot", VALUEFUNC(_wrap_TerrainGroup_convertWorldPositionToTerrainSlot), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "convertTerrainSlotToWorldPosition", VALUEFUNC(_wrap_TerrainGroup_convertTerrainSlotToWorldPosition), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "isDerivedDataUpdateInProgress", VALUEFUNC(_wrap_TerrainGroup_isDerivedDataUpdateInProgress), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "getTerrainIterator", VALUEFUNC(_wrap_TerrainGroup_getTerrainIterator), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "canHandleRequest", VALUEFUNC(_wrap_TerrainGroup_canHandleRequest), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "handleRequest", VALUEFUNC(_wrap_TerrainGroup_handleRequest), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "canHandleResponse", VALUEFUNC(_wrap_TerrainGroup_canHandleResponse), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "handleResponse", VALUEFUNC(_wrap_TerrainGroup_handleResponse), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "packIndex", VALUEFUNC(_wrap_TerrainGroup_packIndex), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "unpackIndex", VALUEFUNC(_wrap_TerrainGroup_unpackIndex), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "generateFilename", VALUEFUNC(_wrap_TerrainGroup_generateFilename), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "saveGroupDefinition", VALUEFUNC(_wrap_TerrainGroup_saveGroupDefinition), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "loadGroupDefinition", VALUEFUNC(_wrap_TerrainGroup_loadGroupDefinition), -1);
  rb_define_singleton_method(SwigClassTerrainGroup.klass, "WORKQUEUE_LOAD_REQUEST", VALUEFUNC(_wrap_TerrainGroup_WORKQUEUE_LOAD_REQUEST_get), 0);
  rb_define_singleton_method(SwigClassTerrainGroup.klass, "CHUNK_ID", VALUEFUNC(_wrap_TerrainGroup_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassTerrainGroup.klass, "CHUNK_VERSION", VALUEFUNC(_wrap_TerrainGroup_CHUNK_VERSION_get), 0);
  rb_define_method(SwigClassTerrainGroup.klass, "setDefaultImportSettings", VALUEFUNC(_wrap_TerrainGroup_setDefaultImportSettings), -1);
  rb_define_method(SwigClassTerrainGroup.klass, "initBlendMaps", VALUEFUNC(_wrap_TerrainGroup_initBlendMaps), -1);
  SwigClassTerrainGroup.mark = 0;
  SwigClassTerrainGroup.destroy = (void (*)(void *)) free_Ogre_TerrainGroup;
  SwigClassTerrainGroup.trackObjects = 0;
  
  SwigClassTerrainLayerBlendMap.klass = rb_define_class_under(mOgre, "TerrainLayerBlendMap", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainLayerBlendMap, (void *) &SwigClassTerrainLayerBlendMap);
  rb_define_alloc_func(SwigClassTerrainLayerBlendMap.klass, _wrap_TerrainLayerBlendMap_allocate);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "initialize", VALUEFUNC(_wrap_new_TerrainLayerBlendMap), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "getParent", VALUEFUNC(_wrap_TerrainLayerBlendMap_getParent), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "getLayerIndex", VALUEFUNC(_wrap_TerrainLayerBlendMap_getLayerIndex), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convertWorldToUVSpace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convertWorldToUVSpace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convertUVToWorldSpace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convertUVToWorldSpace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convertUVToImageSpace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convertUVToImageSpace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convertImageToUVSpace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convertImageToUVSpace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convertImageToTerrainSpace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convertImageToTerrainSpace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "convertTerrainToImageSpace", VALUEFUNC(_wrap_TerrainLayerBlendMap_convertTerrainToImageSpace), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "getBlendValue", VALUEFUNC(_wrap_TerrainLayerBlendMap_getBlendValue), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "setBlendValue", VALUEFUNC(_wrap_TerrainLayerBlendMap_setBlendValue), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "getBlendPointer", VALUEFUNC(_wrap_TerrainLayerBlendMap_getBlendPointer), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "dirty", VALUEFUNC(_wrap_TerrainLayerBlendMap_dirty), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "dirtyRect", VALUEFUNC(_wrap_TerrainLayerBlendMap_dirtyRect), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "blit", VALUEFUNC(_wrap_TerrainLayerBlendMap_blit), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "loadImage", VALUEFUNC(_wrap_TerrainLayerBlendMap_loadImage), -1);
  rb_define_method(SwigClassTerrainLayerBlendMap.klass, "update", VALUEFUNC(_wrap_TerrainLayerBlendMap_update), -1);
  SwigClassTerrainLayerBlendMap.mark = 0;
  SwigClassTerrainLayerBlendMap.destroy = (void (*)(void *)) free_Ogre_TerrainLayerBlendMap;
  SwigClassTerrainLayerBlendMap.trackObjects = 0;
  rb_define_const(mOgre, "TLSS_ALBEDO", SWIG_From_int(static_cast< int >(Ogre::TLSS_ALBEDO)));
  rb_define_const(mOgre, "TLSS_NORMAL", SWIG_From_int(static_cast< int >(Ogre::TLSS_NORMAL)));
  rb_define_const(mOgre, "TLSS_HEIGHT", SWIG_From_int(static_cast< int >(Ogre::TLSS_HEIGHT)));
  rb_define_const(mOgre, "TLSS_SPECULAR", SWIG_From_int(static_cast< int >(Ogre::TLSS_SPECULAR)));
  
  SwigClassTerrainLayerSamplerElement.klass = rb_define_class_under(mOgre, "TerrainLayerSamplerElement", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainLayerSamplerElement, (void *) &SwigClassTerrainLayerSamplerElement);
  rb_define_alloc_func(SwigClassTerrainLayerSamplerElement.klass, _wrap_TerrainLayerSamplerElement_allocate);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "initialize", VALUEFUNC(_wrap_new_TerrainLayerSamplerElement), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "source=", VALUEFUNC(_wrap_TerrainLayerSamplerElement_source_set), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "source", VALUEFUNC(_wrap_TerrainLayerSamplerElement_source_get), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "semantic=", VALUEFUNC(_wrap_TerrainLayerSamplerElement_semantic_set), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "semantic", VALUEFUNC(_wrap_TerrainLayerSamplerElement_semantic_get), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "elementStart=", VALUEFUNC(_wrap_TerrainLayerSamplerElement_elementStart_set), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "elementStart", VALUEFUNC(_wrap_TerrainLayerSamplerElement_elementStart_get), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "elementCount=", VALUEFUNC(_wrap_TerrainLayerSamplerElement_elementCount_set), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "elementCount", VALUEFUNC(_wrap_TerrainLayerSamplerElement_elementCount_get), -1);
  rb_define_method(SwigClassTerrainLayerSamplerElement.klass, "==", VALUEFUNC(_wrap_TerrainLayerSamplerElement___eq__), -1);
  SwigClassTerrainLayerSamplerElement.mark = 0;
  SwigClassTerrainLayerSamplerElement.destroy = (void (*)(void *)) free_Ogre_TerrainLayerSamplerElement;
  SwigClassTerrainLayerSamplerElement.trackObjects = 0;
  
  SwigClassTerrainLayerSampler.klass = rb_define_class_under(mOgre, "TerrainLayerSampler", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainLayerSampler, (void *) &SwigClassTerrainLayerSampler);
  rb_define_alloc_func(SwigClassTerrainLayerSampler.klass, _wrap_TerrainLayerSampler_allocate);
  rb_define_method(SwigClassTerrainLayerSampler.klass, "initialize", VALUEFUNC(_wrap_new_TerrainLayerSampler), -1);
  rb_define_method(SwigClassTerrainLayerSampler.klass, "alias=", VALUEFUNC(_wrap_TerrainLayerSampler_alias_set), -1);
  rb_define_method(SwigClassTerrainLayerSampler.klass, "alias", VALUEFUNC(_wrap_TerrainLayerSampler_alias_get), -1);
  rb_define_method(SwigClassTerrainLayerSampler.klass, "format=", VALUEFUNC(_wrap_TerrainLayerSampler_format_set), -1);
  rb_define_method(SwigClassTerrainLayerSampler.klass, "format", VALUEFUNC(_wrap_TerrainLayerSampler_format_get), -1);
  rb_define_method(SwigClassTerrainLayerSampler.klass, "==", VALUEFUNC(_wrap_TerrainLayerSampler___eq__), -1);
  SwigClassTerrainLayerSampler.mark = 0;
  SwigClassTerrainLayerSampler.destroy = (void (*)(void *)) free_Ogre_TerrainLayerSampler;
  SwigClassTerrainLayerSampler.trackObjects = 0;
  
  SwigClassTerrainLayerDeclaration.klass = rb_define_class_under(mOgre, "TerrainLayerDeclaration", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainLayerDeclaration, (void *) &SwigClassTerrainLayerDeclaration);
  rb_define_alloc_func(SwigClassTerrainLayerDeclaration.klass, _wrap_TerrainLayerDeclaration_allocate);
  rb_define_method(SwigClassTerrainLayerDeclaration.klass, "initialize", VALUEFUNC(_wrap_new_TerrainLayerDeclaration), -1);
  rb_define_method(SwigClassTerrainLayerDeclaration.klass, "samplers=", VALUEFUNC(_wrap_TerrainLayerDeclaration_samplers_set), -1);
  rb_define_method(SwigClassTerrainLayerDeclaration.klass, "samplers", VALUEFUNC(_wrap_TerrainLayerDeclaration_samplers_get), -1);
  rb_define_method(SwigClassTerrainLayerDeclaration.klass, "elements=", VALUEFUNC(_wrap_TerrainLayerDeclaration_elements_set), -1);
  rb_define_method(SwigClassTerrainLayerDeclaration.klass, "elements", VALUEFUNC(_wrap_TerrainLayerDeclaration_elements_get), -1);
  rb_define_method(SwigClassTerrainLayerDeclaration.klass, "==", VALUEFUNC(_wrap_TerrainLayerDeclaration___eq__), -1);
  SwigClassTerrainLayerDeclaration.mark = 0;
  SwigClassTerrainLayerDeclaration.destroy = (void (*)(void *)) free_Ogre_TerrainLayerDeclaration;
  SwigClassTerrainLayerDeclaration.trackObjects = 0;
  
  SwigClassTerrainMaterialGenerator.klass = rb_define_class_under(mOgre, "TerrainMaterialGenerator", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainMaterialGenerator, (void *) &SwigClassTerrainMaterialGenerator);
  rb_define_alloc_func(SwigClassTerrainMaterialGenerator.klass, _wrap_TerrainMaterialGenerator_allocate);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "initialize", VALUEFUNC(_wrap_new_TerrainMaterialGenerator), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "getProfiles", VALUEFUNC(_wrap_TerrainMaterialGenerator_getProfiles), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "setActiveProfile", VALUEFUNC(_wrap_TerrainMaterialGenerator_setActiveProfile), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "getActiveProfile", VALUEFUNC(_wrap_TerrainMaterialGenerator_getActiveProfile), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "_markChanged", VALUEFUNC(_wrap_TerrainMaterialGenerator__markChanged), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "getChangeCount", VALUEFUNC(_wrap_TerrainMaterialGenerator_getChangeCount), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "getLayerDeclaration", VALUEFUNC(_wrap_TerrainMaterialGenerator_getLayerDeclaration), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "canGenerateUsingDeclaration", VALUEFUNC(_wrap_TerrainMaterialGenerator_canGenerateUsingDeclaration), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "isVertexCompressionSupported", VALUEFUNC(_wrap_TerrainMaterialGenerator_isVertexCompressionSupported), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "requestOptions", VALUEFUNC(_wrap_TerrainMaterialGenerator_requestOptions), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "generate", VALUEFUNC(_wrap_TerrainMaterialGenerator_generate), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "generateForCompositeMap", VALUEFUNC(_wrap_TerrainMaterialGenerator_generateForCompositeMap), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "getMaxLayers", VALUEFUNC(_wrap_TerrainMaterialGenerator_getMaxLayers), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "updateCompositeMap", VALUEFUNC(_wrap_TerrainMaterialGenerator_updateCompositeMap), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "updateParams", VALUEFUNC(_wrap_TerrainMaterialGenerator_updateParams), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "updateParamsForCompositeMap", VALUEFUNC(_wrap_TerrainMaterialGenerator_updateParamsForCompositeMap), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "setDebugLevel", VALUEFUNC(_wrap_TerrainMaterialGenerator_setDebugLevel), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "getDebugLevel", VALUEFUNC(_wrap_TerrainMaterialGenerator_getDebugLevel), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "_renderCompositeMap", VALUEFUNC(_wrap_TerrainMaterialGenerator__renderCompositeMap), -1);
  rb_define_method(SwigClassTerrainMaterialGenerator.klass, "_getCompositeMapRTT", VALUEFUNC(_wrap_TerrainMaterialGenerator__getCompositeMapRTT), -1);
  SwigClassTerrainMaterialGenerator.mark = 0;
  SwigClassTerrainMaterialGenerator.destroy = (void (*)(void *)) free_Ogre_TerrainMaterialGenerator;
  SwigClassTerrainMaterialGenerator.trackObjects = 0;
  
  SwigClassTerrainMaterialGeneratorA.klass = rb_define_class_under(mOgre, "TerrainMaterialGeneratorA", ((swig_class *) SWIGTYPE_p_Ogre__TerrainMaterialGenerator->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainMaterialGeneratorA, (void *) &SwigClassTerrainMaterialGeneratorA);
  rb_define_alloc_func(SwigClassTerrainMaterialGeneratorA.klass, _wrap_TerrainMaterialGeneratorA_allocate);
  rb_define_method(SwigClassTerrainMaterialGeneratorA.klass, "initialize", VALUEFUNC(_wrap_new_TerrainMaterialGeneratorA), -1);
  SwigClassTerrainMaterialGeneratorA.mark = 0;
  SwigClassTerrainMaterialGeneratorA.destroy = (void (*)(void *)) free_Ogre_TerrainMaterialGeneratorA;
  SwigClassTerrainMaterialGeneratorA.trackObjects = 0;
  
  SwigClassTerrainPagedWorldSection.klass = rb_define_class_under(mOgre, "TerrainPagedWorldSection", ((swig_class *) SWIGTYPE_p_Ogre__PagedWorldSection->clientdata)->klass);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainPagedWorldSection, (void *) &SwigClassTerrainPagedWorldSection);
  rb_define_alloc_func(SwigClassTerrainPagedWorldSection.klass, _wrap_TerrainPagedWorldSection_allocate);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "initialize", VALUEFUNC(_wrap_new_TerrainPagedWorldSection), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "init", VALUEFUNC(_wrap_TerrainPagedWorldSection_init), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getTerrainGroup", VALUEFUNC(_wrap_TerrainPagedWorldSection_getTerrainGroup), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "setLoadRadius", VALUEFUNC(_wrap_TerrainPagedWorldSection_setLoadRadius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getLoadRadius", VALUEFUNC(_wrap_TerrainPagedWorldSection_getLoadRadius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "setHoldRadius", VALUEFUNC(_wrap_TerrainPagedWorldSection_setHoldRadius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getHoldRadius", VALUEFUNC(_wrap_TerrainPagedWorldSection_getHoldRadius), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "setPageRange", VALUEFUNC(_wrap_TerrainPagedWorldSection_setPageRange), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "setPageRangeMinX", VALUEFUNC(_wrap_TerrainPagedWorldSection_setPageRangeMinX), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "setPageRangeMinY", VALUEFUNC(_wrap_TerrainPagedWorldSection_setPageRangeMinY), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "setPageRangeMaxX", VALUEFUNC(_wrap_TerrainPagedWorldSection_setPageRangeMaxX), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "setPageRangeMaxY", VALUEFUNC(_wrap_TerrainPagedWorldSection_setPageRangeMaxY), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getPageRangeMinX", VALUEFUNC(_wrap_TerrainPagedWorldSection_getPageRangeMinX), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getPageRangeMinY", VALUEFUNC(_wrap_TerrainPagedWorldSection_getPageRangeMinY), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getPageRangeMaxX", VALUEFUNC(_wrap_TerrainPagedWorldSection_getPageRangeMaxX), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getPageRangeMaxY", VALUEFUNC(_wrap_TerrainPagedWorldSection_getPageRangeMaxY), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getGridStrategy", VALUEFUNC(_wrap_TerrainPagedWorldSection_getGridStrategy), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "getGridStrategyData", VALUEFUNC(_wrap_TerrainPagedWorldSection_getGridStrategyData), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "loadPage", VALUEFUNC(_wrap_TerrainPagedWorldSection_loadPage), -1);
  rb_define_method(SwigClassTerrainPagedWorldSection.klass, "unloadPage", VALUEFUNC(_wrap_TerrainPagedWorldSection_unloadPage), -1);
  SwigClassTerrainPagedWorldSection.mark = 0;
  SwigClassTerrainPagedWorldSection.destroy = (void (*)(void *)) free_Ogre_TerrainPagedWorldSection;
  SwigClassTerrainPagedWorldSection.trackObjects = 0;
  
  SwigClassTerrainPaging.klass = rb_define_class_under(mOgre, "TerrainPaging", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainPaging, (void *) &SwigClassTerrainPaging);
  rb_define_alloc_func(SwigClassTerrainPaging.klass, _wrap_TerrainPaging_allocate);
  rb_define_method(SwigClassTerrainPaging.klass, "initialize", VALUEFUNC(_wrap_new_TerrainPaging), -1);
  rb_define_method(SwigClassTerrainPaging.klass, "createWorldSection", VALUEFUNC(_wrap_TerrainPaging_createWorldSection), -1);
  SwigClassTerrainPaging.mark = 0;
  SwigClassTerrainPaging.destroy = (void (*)(void *)) free_Ogre_TerrainPaging;
  SwigClassTerrainPaging.trackObjects = 0;
  
  SwigClassTerrainQuadTreeNode.klass = rb_define_class_under(mOgre, "TerrainQuadTreeNode", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainQuadTreeNode, (void *) &SwigClassTerrainQuadTreeNode);
  rb_define_alloc_func(SwigClassTerrainQuadTreeNode.klass, _wrap_TerrainQuadTreeNode_allocate);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "initialize", VALUEFUNC(_wrap_new_TerrainQuadTreeNode), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getXOffset", VALUEFUNC(_wrap_TerrainQuadTreeNode_getXOffset), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getYOffset", VALUEFUNC(_wrap_TerrainQuadTreeNode_getYOffset), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "isLeaf", VALUEFUNC(_wrap_TerrainQuadTreeNode_isLeaf), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getBaseLod", VALUEFUNC(_wrap_TerrainQuadTreeNode_getBaseLod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getLodCount", VALUEFUNC(_wrap_TerrainQuadTreeNode_getLodCount), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getChild", VALUEFUNC(_wrap_TerrainQuadTreeNode_getChild), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getParent", VALUEFUNC(_wrap_TerrainQuadTreeNode_getParent), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getTerrain", VALUEFUNC(_wrap_TerrainQuadTreeNode_getTerrain), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "prepare", VALUEFUNC(_wrap_TerrainQuadTreeNode_prepare), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "load", VALUEFUNC(_wrap_TerrainQuadTreeNode_load), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "unload", VALUEFUNC(_wrap_TerrainQuadTreeNode_unload), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "unprepare", VALUEFUNC(_wrap_TerrainQuadTreeNode_unprepare), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "save", VALUEFUNC(_wrap_TerrainQuadTreeNode_save), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getLodLevel", VALUEFUNC(_wrap_TerrainQuadTreeNode_getLodLevel), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "preDeltaCalculation", VALUEFUNC(_wrap_TerrainQuadTreeNode_preDeltaCalculation), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "notifyDelta", VALUEFUNC(_wrap_TerrainQuadTreeNode_notifyDelta), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "postDeltaCalculation", VALUEFUNC(_wrap_TerrainQuadTreeNode_postDeltaCalculation), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "finaliseDeltaValues", VALUEFUNC(_wrap_TerrainQuadTreeNode_finaliseDeltaValues), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "assignVertexData", VALUEFUNC(_wrap_TerrainQuadTreeNode_assignVertexData), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "useAncestorVertexData", VALUEFUNC(_wrap_TerrainQuadTreeNode_useAncestorVertexData), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "updateVertexData", VALUEFUNC(_wrap_TerrainQuadTreeNode_updateVertexData), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "mergeIntoBounds", VALUEFUNC(_wrap_TerrainQuadTreeNode_mergeIntoBounds), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "resetBounds", VALUEFUNC(_wrap_TerrainQuadTreeNode_resetBounds), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "rectIntersectsNode", VALUEFUNC(_wrap_TerrainQuadTreeNode_rectIntersectsNode), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "rectContainsNode", VALUEFUNC(_wrap_TerrainQuadTreeNode_rectContainsNode), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "pointIntersectsNode", VALUEFUNC(_wrap_TerrainQuadTreeNode_pointIntersectsNode), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getAABB", VALUEFUNC(_wrap_TerrainQuadTreeNode_getAABB), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getBoundingRadius", VALUEFUNC(_wrap_TerrainQuadTreeNode_getBoundingRadius), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getLocalCentre", VALUEFUNC(_wrap_TerrainQuadTreeNode_getLocalCentre), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getMinHeight", VALUEFUNC(_wrap_TerrainQuadTreeNode_getMinHeight), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getMaxHeight", VALUEFUNC(_wrap_TerrainQuadTreeNode_getMaxHeight), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "calculateCurrentLod", VALUEFUNC(_wrap_TerrainQuadTreeNode_calculateCurrentLod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getCurrentLod", VALUEFUNC(_wrap_TerrainQuadTreeNode_getCurrentLod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "isRenderedAtCurrentLod", VALUEFUNC(_wrap_TerrainQuadTreeNode_isRenderedAtCurrentLod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "isSelfOrChildRenderedAtCurrentLod", VALUEFUNC(_wrap_TerrainQuadTreeNode_isSelfOrChildRenderedAtCurrentLod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "setCurrentLod", VALUEFUNC(_wrap_TerrainQuadTreeNode_setCurrentLod), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "getLodTransition", VALUEFUNC(_wrap_TerrainQuadTreeNode_getLodTransition), -1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "setLodTransition", VALUEFUNC(_wrap_TerrainQuadTreeNode_setLodTransition), -1);
  rb_define_singleton_method(SwigClassTerrainQuadTreeNode.klass, "POSITION_BUFFER", VALUEFUNC(_wrap_TerrainQuadTreeNode_POSITION_BUFFER_get), 0);
  rb_define_singleton_method(SwigClassTerrainQuadTreeNode.klass, "POSITION_BUFFER=", VALUEFUNC(_wrap_TerrainQuadTreeNode_POSITION_BUFFER_set), 1);
  rb_define_singleton_method(SwigClassTerrainQuadTreeNode.klass, "DELTA_BUFFER", VALUEFUNC(_wrap_TerrainQuadTreeNode_DELTA_BUFFER_get), 0);
  rb_define_singleton_method(SwigClassTerrainQuadTreeNode.klass, "DELTA_BUFFER=", VALUEFUNC(_wrap_TerrainQuadTreeNode_DELTA_BUFFER_set), 1);
  rb_define_method(SwigClassTerrainQuadTreeNode.klass, "_getRenderable", VALUEFUNC(_wrap_TerrainQuadTreeNode__getRenderable), -1);
  SwigClassTerrainQuadTreeNode.mark = 0;
  SwigClassTerrainQuadTreeNode.destroy = (void (*)(void *)) free_Ogre_TerrainQuadTreeNode;
  SwigClassTerrainQuadTreeNode.trackObjects = 0;
  
  SwigClassTerrain.klass = rb_define_class_under(mOgre, "Terrain", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__Terrain, (void *) &SwigClassTerrain);
  rb_define_alloc_func(SwigClassTerrain.klass, _wrap_Terrain_allocate);
  rb_define_method(SwigClassTerrain.klass, "initialize", VALUEFUNC(_wrap_new_Terrain), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAIN_CHUNK_ID", VALUEFUNC(_wrap_Terrain_TERRAIN_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAIN_CHUNK_VERSION", VALUEFUNC(_wrap_Terrain_TERRAIN_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAIN_MAX_BATCH_SIZE", VALUEFUNC(_wrap_Terrain_TERRAIN_MAX_BATCH_SIZE_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERDECLARATION_CHUNK_ID", VALUEFUNC(_wrap_Terrain_TERRAINLAYERDECLARATION_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERDECLARATION_CHUNK_VERSION", VALUEFUNC(_wrap_Terrain_TERRAINLAYERDECLARATION_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERSAMPLER_CHUNK_ID", VALUEFUNC(_wrap_Terrain_TERRAINLAYERSAMPLER_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERSAMPLER_CHUNK_VERSION", VALUEFUNC(_wrap_Terrain_TERRAINLAYERSAMPLER_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERSAMPLERELEMENT_CHUNK_ID", VALUEFUNC(_wrap_Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION", VALUEFUNC(_wrap_Terrain_TERRAINLAYERSAMPLERELEMENT_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERINSTANCE_CHUNK_ID", VALUEFUNC(_wrap_Terrain_TERRAINLAYERINSTANCE_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINLAYERINSTANCE_CHUNK_VERSION", VALUEFUNC(_wrap_Terrain_TERRAINLAYERINSTANCE_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINDERIVEDDATA_CHUNK_ID", VALUEFUNC(_wrap_Terrain_TERRAINDERIVEDDATA_CHUNK_ID_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "TERRAINDERIVEDDATA_CHUNK_VERSION", VALUEFUNC(_wrap_Terrain_TERRAINDERIVEDDATA_CHUNK_VERSION_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "LOD_MORPH_CUSTOM_PARAM", VALUEFUNC(_wrap_Terrain_LOD_MORPH_CUSTOM_PARAM_get), 0);
  rb_define_const(SwigClassTerrain.klass, "ALIGN_X_Z", SWIG_From_int(static_cast< int >(Ogre::Terrain::ALIGN_X_Z)));
  rb_define_const(SwigClassTerrain.klass, "ALIGN_X_Y", SWIG_From_int(static_cast< int >(Ogre::Terrain::ALIGN_X_Y)));
  rb_define_const(SwigClassTerrain.klass, "ALIGN_Y_Z", SWIG_From_int(static_cast< int >(Ogre::Terrain::ALIGN_Y_Z)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_EAST", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_EAST)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_NORTHEAST", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_NORTHEAST)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_NORTH", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_NORTH)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_NORTHWEST", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_NORTHWEST)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_WEST", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_WEST)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_SOUTHWEST", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_SOUTHWEST)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_SOUTH", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_SOUTH)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_SOUTHEAST", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_SOUTHEAST)));
  rb_define_const(SwigClassTerrain.klass, "NEIGHBOUR_COUNT", SWIG_From_int(static_cast< int >(Ogre::Terrain::NEIGHBOUR_COUNT)));
  rb_define_method(SwigClassTerrain.klass, "getSceneManager", VALUEFUNC(_wrap_Terrain_getSceneManager), -1);
  rb_define_const(SwigClassTerrain.klass, "WORLD_SPACE", SWIG_From_int(static_cast< int >(Ogre::Terrain::WORLD_SPACE)));
  rb_define_const(SwigClassTerrain.klass, "LOCAL_SPACE", SWIG_From_int(static_cast< int >(Ogre::Terrain::LOCAL_SPACE)));
  rb_define_const(SwigClassTerrain.klass, "TERRAIN_SPACE", SWIG_From_int(static_cast< int >(Ogre::Terrain::TERRAIN_SPACE)));
  rb_define_const(SwigClassTerrain.klass, "POINT_SPACE", SWIG_From_int(static_cast< int >(Ogre::Terrain::POINT_SPACE)));
  rb_define_method(SwigClassTerrain.klass, "setGpuBufferAllocator", VALUEFUNC(_wrap_Terrain_setGpuBufferAllocator), -1);
  rb_define_method(SwigClassTerrain.klass, "getGpuBufferAllocator", VALUEFUNC(_wrap_Terrain_getGpuBufferAllocator), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "_getNumIndexesForBatchSize", VALUEFUNC(_wrap_Terrain__getNumIndexesForBatchSize), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "_populateIndexBuffer", VALUEFUNC(_wrap_Terrain__populateIndexBuffer), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "_calcSkirtVertexIndex", VALUEFUNC(_wrap_Terrain__calcSkirtVertexIndex), -1);
  rb_define_method(SwigClassTerrain.klass, "convertPosition", VALUEFUNC(_wrap_Terrain_convertPosition), -1);
  rb_define_method(SwigClassTerrain.klass, "convertDirection", VALUEFUNC(_wrap_Terrain_convertDirection), -1);
  rb_define_method(SwigClassTerrain.klass, "setResourceGroup", VALUEFUNC(_wrap_Terrain_setResourceGroup), -1);
  rb_define_method(SwigClassTerrain.klass, "getResourceGroup", VALUEFUNC(_wrap_Terrain_getResourceGroup), -1);
  rb_define_method(SwigClassTerrain.klass, "_getDerivedResourceGroup", VALUEFUNC(_wrap_Terrain__getDerivedResourceGroup), -1);
  rb_define_method(SwigClassTerrain.klass, "save", VALUEFUNC(_wrap_Terrain_save), -1);
  rb_define_method(SwigClassTerrain.klass, "prepare", VALUEFUNC(_wrap_Terrain_prepare), -1);
  rb_define_method(SwigClassTerrain.klass, "load", VALUEFUNC(_wrap_Terrain_load), -1);
  rb_define_method(SwigClassTerrain.klass, "isLoaded", VALUEFUNC(_wrap_Terrain_isLoaded), -1);
  rb_define_method(SwigClassTerrain.klass, "isModified", VALUEFUNC(_wrap_Terrain_isModified), -1);
  rb_define_method(SwigClassTerrain.klass, "isHeightDataModified", VALUEFUNC(_wrap_Terrain_isHeightDataModified), -1);
  rb_define_method(SwigClassTerrain.klass, "unload", VALUEFUNC(_wrap_Terrain_unload), -1);
  rb_define_method(SwigClassTerrain.klass, "unprepare", VALUEFUNC(_wrap_Terrain_unprepare), -1);
  rb_define_method(SwigClassTerrain.klass, "getHeightData", VALUEFUNC(_wrap_Terrain_getHeightData), -1);
  rb_define_method(SwigClassTerrain.klass, "getHeightAtPoint", VALUEFUNC(_wrap_Terrain_getHeightAtPoint), -1);
  rb_define_method(SwigClassTerrain.klass, "setHeightAtPoint", VALUEFUNC(_wrap_Terrain_setHeightAtPoint), -1);
  rb_define_method(SwigClassTerrain.klass, "getHeightAtTerrainPosition", VALUEFUNC(_wrap_Terrain_getHeightAtTerrainPosition), -1);
  rb_define_method(SwigClassTerrain.klass, "getHeightAtWorldPosition", VALUEFUNC(_wrap_Terrain_getHeightAtWorldPosition), -1);
  rb_define_method(SwigClassTerrain.klass, "getDeltaData", VALUEFUNC(_wrap_Terrain_getDeltaData), -1);
  rb_define_method(SwigClassTerrain.klass, "getPointFromSelfOrNeighbour", VALUEFUNC(_wrap_Terrain_getPointFromSelfOrNeighbour), -1);
  rb_define_method(SwigClassTerrain.klass, "getPoint", VALUEFUNC(_wrap_Terrain_getPoint), -1);
  rb_define_method(SwigClassTerrain.klass, "getPointTransform", VALUEFUNC(_wrap_Terrain_getPointTransform), -1);
  rb_define_method(SwigClassTerrain.klass, "getTerrainVector", VALUEFUNC(_wrap_Terrain_getTerrainVector), -1);
  rb_define_method(SwigClassTerrain.klass, "getTerrainVectorAlign", VALUEFUNC(_wrap_Terrain_getTerrainVectorAlign), -1);
  rb_define_method(SwigClassTerrain.klass, "getVector", VALUEFUNC(_wrap_Terrain_getVector), -1);
  rb_define_method(SwigClassTerrain.klass, "getVectorAlign", VALUEFUNC(_wrap_Terrain_getVectorAlign), -1);
  rb_define_method(SwigClassTerrain.klass, "getTerrainPosition", VALUEFUNC(_wrap_Terrain_getTerrainPosition), -1);
  rb_define_method(SwigClassTerrain.klass, "getPositionAlign", VALUEFUNC(_wrap_Terrain_getPositionAlign), -1);
  rb_define_method(SwigClassTerrain.klass, "getTerrainPositionAlign", VALUEFUNC(_wrap_Terrain_getTerrainPositionAlign), -1);
  rb_define_method(SwigClassTerrain.klass, "getAlignment", VALUEFUNC(_wrap_Terrain_getAlignment), -1);
  rb_define_method(SwigClassTerrain.klass, "getSize", VALUEFUNC(_wrap_Terrain_getSize), -1);
  rb_define_method(SwigClassTerrain.klass, "setSize", VALUEFUNC(_wrap_Terrain_setSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getMaxBatchSize", VALUEFUNC(_wrap_Terrain_getMaxBatchSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getMinBatchSize", VALUEFUNC(_wrap_Terrain_getMinBatchSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getWorldSize", VALUEFUNC(_wrap_Terrain_getWorldSize), -1);
  rb_define_method(SwigClassTerrain.klass, "setWorldSize", VALUEFUNC(_wrap_Terrain_setWorldSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerCount", VALUEFUNC(_wrap_Terrain_getLayerCount), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerDeclaration", VALUEFUNC(_wrap_Terrain_getLayerDeclaration), -1);
  rb_define_method(SwigClassTerrain.klass, "addLayer", VALUEFUNC(_wrap_Terrain_addLayer), -1);
  rb_define_method(SwigClassTerrain.klass, "removeLayer", VALUEFUNC(_wrap_Terrain_removeLayer), -1);
  rb_define_method(SwigClassTerrain.klass, "replaceLayer", VALUEFUNC(_wrap_Terrain_replaceLayer), -1);
  rb_define_method(SwigClassTerrain.klass, "getMaxLayers", VALUEFUNC(_wrap_Terrain_getMaxLayers), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerWorldSize", VALUEFUNC(_wrap_Terrain_getLayerWorldSize), -1);
  rb_define_method(SwigClassTerrain.klass, "setLayerWorldSize", VALUEFUNC(_wrap_Terrain_setLayerWorldSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerUVMultiplier", VALUEFUNC(_wrap_Terrain_getLayerUVMultiplier), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerTextureName", VALUEFUNC(_wrap_Terrain_getLayerTextureName), -1);
  rb_define_method(SwigClassTerrain.klass, "setLayerTextureName", VALUEFUNC(_wrap_Terrain_setLayerTextureName), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerBlendMapSize", VALUEFUNC(_wrap_Terrain_getLayerBlendMapSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getLightmapSize", VALUEFUNC(_wrap_Terrain_getLightmapSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getLightmap", VALUEFUNC(_wrap_Terrain_getLightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "getCompositeMapSize", VALUEFUNC(_wrap_Terrain_getCompositeMapSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getCompositeMap", VALUEFUNC(_wrap_Terrain_getCompositeMap), -1);
  rb_define_method(SwigClassTerrain.klass, "getPosition", VALUEFUNC(_wrap_Terrain_getPosition), -1);
  rb_define_method(SwigClassTerrain.klass, "setPosition", VALUEFUNC(_wrap_Terrain_setPosition), -1);
  rb_define_method(SwigClassTerrain.klass, "_getRootSceneNode", VALUEFUNC(_wrap_Terrain__getRootSceneNode), -1);
  rb_define_method(SwigClassTerrain.klass, "dirty", VALUEFUNC(_wrap_Terrain_dirty), -1);
  rb_define_method(SwigClassTerrain.klass, "dirtyRect", VALUEFUNC(_wrap_Terrain_dirtyRect), -1);
  rb_define_method(SwigClassTerrain.klass, "_dirtyCompositeMapRect", VALUEFUNC(_wrap_Terrain__dirtyCompositeMapRect), -1);
  rb_define_method(SwigClassTerrain.klass, "dirtyLightmapRect", VALUEFUNC(_wrap_Terrain_dirtyLightmapRect), -1);
  rb_define_method(SwigClassTerrain.klass, "dirtyLightmap", VALUEFUNC(_wrap_Terrain_dirtyLightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "update", VALUEFUNC(_wrap_Terrain_update), -1);
  rb_define_method(SwigClassTerrain.klass, "updateGeometry", VALUEFUNC(_wrap_Terrain_updateGeometry), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "DERIVED_DATA_DELTAS", VALUEFUNC(_wrap_Terrain_DERIVED_DATA_DELTAS_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "DERIVED_DATA_NORMALS", VALUEFUNC(_wrap_Terrain_DERIVED_DATA_NORMALS_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "DERIVED_DATA_LIGHTMAP", VALUEFUNC(_wrap_Terrain_DERIVED_DATA_LIGHTMAP_get), 0);
  rb_define_singleton_method(SwigClassTerrain.klass, "DERIVED_DATA_ALL", VALUEFUNC(_wrap_Terrain_DERIVED_DATA_ALL_get), 0);
  rb_define_method(SwigClassTerrain.klass, "updateDerivedData", VALUEFUNC(_wrap_Terrain_updateDerivedData), -1);
  rb_define_method(SwigClassTerrain.klass, "updateCompositeMap", VALUEFUNC(_wrap_Terrain_updateCompositeMap), -1);
  rb_define_method(SwigClassTerrain.klass, "updateCompositeMapWithDelay", VALUEFUNC(_wrap_Terrain_updateCompositeMapWithDelay), -1);
  rb_define_method(SwigClassTerrain.klass, "getSkirtSize", VALUEFUNC(_wrap_Terrain_getSkirtSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getNumLodLevels", VALUEFUNC(_wrap_Terrain_getNumLodLevels), -1);
  rb_define_method(SwigClassTerrain.klass, "getNumLodLevelsPerLeaf", VALUEFUNC(_wrap_Terrain_getNumLodLevelsPerLeaf), -1);
  rb_define_method(SwigClassTerrain.klass, "calculateHeightDeltas", VALUEFUNC(_wrap_Terrain_calculateHeightDeltas), -1);
  rb_define_method(SwigClassTerrain.klass, "finaliseHeightDeltas", VALUEFUNC(_wrap_Terrain_finaliseHeightDeltas), -1);
  rb_define_method(SwigClassTerrain.klass, "calculateNormals", VALUEFUNC(_wrap_Terrain_calculateNormals), -1);
  rb_define_method(SwigClassTerrain.klass, "finaliseNormals", VALUEFUNC(_wrap_Terrain_finaliseNormals), -1);
  rb_define_method(SwigClassTerrain.klass, "calculateLightmap", VALUEFUNC(_wrap_Terrain_calculateLightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "finaliseLightmap", VALUEFUNC(_wrap_Terrain_finaliseLightmap), -1);
  rb_define_method(SwigClassTerrain.klass, "getResolutionAtLod", VALUEFUNC(_wrap_Terrain_getResolutionAtLod), -1);
  rb_define_method(SwigClassTerrain.klass, "rayIntersects", VALUEFUNC(_wrap_Terrain_rayIntersects), -1);
  rb_define_method(SwigClassTerrain.klass, "getAABB", VALUEFUNC(_wrap_Terrain_getAABB), -1);
  rb_define_method(SwigClassTerrain.klass, "getWorldAABB", VALUEFUNC(_wrap_Terrain_getWorldAABB), -1);
  rb_define_method(SwigClassTerrain.klass, "getMinHeight", VALUEFUNC(_wrap_Terrain_getMinHeight), -1);
  rb_define_method(SwigClassTerrain.klass, "getMaxHeight", VALUEFUNC(_wrap_Terrain_getMaxHeight), -1);
  rb_define_method(SwigClassTerrain.klass, "getBoundingRadius", VALUEFUNC(_wrap_Terrain_getBoundingRadius), -1);
  rb_define_method(SwigClassTerrain.klass, "getMaterial", VALUEFUNC(_wrap_Terrain_getMaterial), -1);
  rb_define_method(SwigClassTerrain.klass, "_getMaterial", VALUEFUNC(_wrap_Terrain__getMaterial), -1);
  rb_define_method(SwigClassTerrain.klass, "getCompositeMapMaterial", VALUEFUNC(_wrap_Terrain_getCompositeMapMaterial), -1);
  rb_define_method(SwigClassTerrain.klass, "_getCompositeMapMaterial", VALUEFUNC(_wrap_Terrain__getCompositeMapMaterial), -1);
  rb_define_method(SwigClassTerrain.klass, "getMaterialName", VALUEFUNC(_wrap_Terrain_getMaterialName), -1);
  rb_define_method(SwigClassTerrain.klass, "preFindVisibleObjects", VALUEFUNC(_wrap_Terrain_preFindVisibleObjects), -1);
  rb_define_method(SwigClassTerrain.klass, "sceneManagerDestroyed", VALUEFUNC(_wrap_Terrain_sceneManagerDestroyed), -1);
  rb_define_method(SwigClassTerrain.klass, "getRenderQueueGroup", VALUEFUNC(_wrap_Terrain_getRenderQueueGroup), -1);
  rb_define_method(SwigClassTerrain.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_Terrain_setRenderQueueGroup), -1);
  rb_define_method(SwigClassTerrain.klass, "getVisibilityFlags", VALUEFUNC(_wrap_Terrain_getVisibilityFlags), -1);
  rb_define_method(SwigClassTerrain.klass, "setVisibilityFlags", VALUEFUNC(_wrap_Terrain_setVisibilityFlags), -1);
  rb_define_method(SwigClassTerrain.klass, "getQueryFlags", VALUEFUNC(_wrap_Terrain_getQueryFlags), -1);
  rb_define_method(SwigClassTerrain.klass, "setQueryFlags", VALUEFUNC(_wrap_Terrain_setQueryFlags), -1);
  rb_define_method(SwigClassTerrain.klass, "addQueryFlags", VALUEFUNC(_wrap_Terrain_addQueryFlags), -1);
  rb_define_method(SwigClassTerrain.klass, "removeQueryFlags", VALUEFUNC(_wrap_Terrain_removeQueryFlags), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerBlendMap", VALUEFUNC(_wrap_Terrain_getLayerBlendMap), -1);
  rb_define_method(SwigClassTerrain.klass, "getBlendTextureIndex", VALUEFUNC(_wrap_Terrain_getBlendTextureIndex), -1);
  rb_define_method(SwigClassTerrain.klass, "getBlendTextureCount", VALUEFUNC(_wrap_Terrain_getBlendTextureCount), -1);
  rb_define_method(SwigClassTerrain.klass, "getBlendTextureName", VALUEFUNC(_wrap_Terrain_getBlendTextureName), -1);
  rb_define_method(SwigClassTerrain.klass, "setGlobalColourMapEnabled", VALUEFUNC(_wrap_Terrain_setGlobalColourMapEnabled), -1);
  rb_define_method(SwigClassTerrain.klass, "getGlobalColourMapEnabled", VALUEFUNC(_wrap_Terrain_getGlobalColourMapEnabled), -1);
  rb_define_method(SwigClassTerrain.klass, "getGlobalColourMapSize", VALUEFUNC(_wrap_Terrain_getGlobalColourMapSize), -1);
  rb_define_method(SwigClassTerrain.klass, "getGlobalColourMap", VALUEFUNC(_wrap_Terrain_getGlobalColourMap), -1);
  rb_define_method(SwigClassTerrain.klass, "widenRectByVector", VALUEFUNC(_wrap_Terrain_widenRectByVector), -1);
  rb_define_method(SwigClassTerrain.klass, "freeTemporaryResources", VALUEFUNC(_wrap_Terrain_freeTemporaryResources), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerBlendTexture", VALUEFUNC(_wrap_Terrain_getLayerBlendTexture), -1);
  rb_define_method(SwigClassTerrain.klass, "getLayerBlendTextureIndex", VALUEFUNC(_wrap_Terrain_getLayerBlendTextureIndex), -1);
  rb_define_method(SwigClassTerrain.klass, "_setMorphRequired", VALUEFUNC(_wrap_Terrain__setMorphRequired), -1);
  rb_define_method(SwigClassTerrain.klass, "_getMorphRequired", VALUEFUNC(_wrap_Terrain__getMorphRequired), -1);
  rb_define_method(SwigClassTerrain.klass, "_setNormalMapRequired", VALUEFUNC(_wrap_Terrain__setNormalMapRequired), -1);
  rb_define_method(SwigClassTerrain.klass, "_setLightMapRequired", VALUEFUNC(_wrap_Terrain__setLightMapRequired), -1);
  rb_define_method(SwigClassTerrain.klass, "_setCompositeMapRequired", VALUEFUNC(_wrap_Terrain__setCompositeMapRequired), -1);
  rb_define_method(SwigClassTerrain.klass, "_getUseVertexCompression", VALUEFUNC(_wrap_Terrain__getUseVertexCompression), -1);
  rb_define_method(SwigClassTerrain.klass, "canHandleRequest", VALUEFUNC(_wrap_Terrain_canHandleRequest), -1);
  rb_define_method(SwigClassTerrain.klass, "handleRequest", VALUEFUNC(_wrap_Terrain_handleRequest), -1);
  rb_define_method(SwigClassTerrain.klass, "canHandleResponse", VALUEFUNC(_wrap_Terrain_canHandleResponse), -1);
  rb_define_method(SwigClassTerrain.klass, "handleResponse", VALUEFUNC(_wrap_Terrain_handleResponse), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "WORKQUEUE_DERIVED_DATA_REQUEST", VALUEFUNC(_wrap_Terrain_WORKQUEUE_DERIVED_DATA_REQUEST_get), 0);
  rb_define_method(SwigClassTerrain.klass, "getLODLevelWhenVertexEliminated", VALUEFUNC(_wrap_Terrain_getLODLevelWhenVertexEliminated), -1);
  rb_define_method(SwigClassTerrain.klass, "getQuadTree", VALUEFUNC(_wrap_Terrain_getQuadTree), -1);
  rb_define_method(SwigClassTerrain.klass, "getTerrainNormalMap", VALUEFUNC(_wrap_Terrain_getTerrainNormalMap), -1);
  rb_define_method(SwigClassTerrain.klass, "getNeighbour", VALUEFUNC(_wrap_Terrain_getNeighbour), -1);
  rb_define_method(SwigClassTerrain.klass, "setNeighbour", VALUEFUNC(_wrap_Terrain_setNeighbour), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "getOppositeNeighbour", VALUEFUNC(_wrap_Terrain_getOppositeNeighbour), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "getNeighbourIndex", VALUEFUNC(_wrap_Terrain_getNeighbourIndex), -1);
  rb_define_method(SwigClassTerrain.klass, "notifyNeighbours", VALUEFUNC(_wrap_Terrain_notifyNeighbours), -1);
  rb_define_method(SwigClassTerrain.klass, "neighbourModified", VALUEFUNC(_wrap_Terrain_neighbourModified), -1);
  rb_define_method(SwigClassTerrain.klass, "raySelectNeighbour", VALUEFUNC(_wrap_Terrain_raySelectNeighbour), -1);
  rb_define_method(SwigClassTerrain.klass, "_dumpTextures", VALUEFUNC(_wrap_Terrain__dumpTextures), -1);
  rb_define_method(SwigClassTerrain.klass, "isDerivedDataUpdateInProgress", VALUEFUNC(_wrap_Terrain_isDerivedDataUpdateInProgress), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "convertWorldToTerrainAxes", VALUEFUNC(_wrap_Terrain_convertWorldToTerrainAxes), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "convertTerrainToWorldAxes", VALUEFUNC(_wrap_Terrain_convertTerrainToWorldAxes), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "writeLayerDeclaration", VALUEFUNC(_wrap_Terrain_writeLayerDeclaration), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "readLayerDeclaration", VALUEFUNC(_wrap_Terrain_readLayerDeclaration), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "writeLayerInstanceList", VALUEFUNC(_wrap_Terrain_writeLayerInstanceList), -1);
  rb_define_singleton_method(SwigClassTerrain.klass, "readLayerInstanceList", VALUEFUNC(_wrap_Terrain_readLayerInstanceList), -1);
  SwigClassTerrain.mark = 0;
  SwigClassTerrain.destroy = (void (*)(void *)) free_Ogre_Terrain;
  SwigClassTerrain.trackObjects = 0;
  
  SwigClassTerrainGlobalOptions.klass = rb_define_class_under(mOgre, "TerrainGlobalOptions", rb_cObject);
  SWIG_TypeClientData(SWIGTYPE_p_Ogre__TerrainGlobalOptions, (void *) &SwigClassTerrainGlobalOptions);
  rb_define_alloc_func(SwigClassTerrainGlobalOptions.klass, _wrap_TerrainGlobalOptions_allocate);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "initialize", VALUEFUNC(_wrap_new_TerrainGlobalOptions), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getSkirtSize", VALUEFUNC(_wrap_TerrainGlobalOptions_getSkirtSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setSkirtSize", VALUEFUNC(_wrap_TerrainGlobalOptions_setSkirtSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getLightMapDirection", VALUEFUNC(_wrap_TerrainGlobalOptions_getLightMapDirection), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setLightMapDirection", VALUEFUNC(_wrap_TerrainGlobalOptions_setLightMapDirection), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getCompositeMapAmbient", VALUEFUNC(_wrap_TerrainGlobalOptions_getCompositeMapAmbient), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setCompositeMapAmbient", VALUEFUNC(_wrap_TerrainGlobalOptions_setCompositeMapAmbient), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getCompositeMapDiffuse", VALUEFUNC(_wrap_TerrainGlobalOptions_getCompositeMapDiffuse), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setCompositeMapDiffuse", VALUEFUNC(_wrap_TerrainGlobalOptions_setCompositeMapDiffuse), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getCompositeMapDistance", VALUEFUNC(_wrap_TerrainGlobalOptions_getCompositeMapDistance), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setCompositeMapDistance", VALUEFUNC(_wrap_TerrainGlobalOptions_setCompositeMapDistance), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getCastsDynamicShadows", VALUEFUNC(_wrap_TerrainGlobalOptions_getCastsDynamicShadows), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setCastsDynamicShadows", VALUEFUNC(_wrap_TerrainGlobalOptions_setCastsDynamicShadows), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getMaxPixelError", VALUEFUNC(_wrap_TerrainGlobalOptions_getMaxPixelError), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setMaxPixelError", VALUEFUNC(_wrap_TerrainGlobalOptions_setMaxPixelError), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getRenderQueueGroup", VALUEFUNC(_wrap_TerrainGlobalOptions_getRenderQueueGroup), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setRenderQueueGroup", VALUEFUNC(_wrap_TerrainGlobalOptions_setRenderQueueGroup), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getVisibilityFlags", VALUEFUNC(_wrap_TerrainGlobalOptions_getVisibilityFlags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setVisibilityFlags", VALUEFUNC(_wrap_TerrainGlobalOptions_setVisibilityFlags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setQueryFlags", VALUEFUNC(_wrap_TerrainGlobalOptions_setQueryFlags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getQueryFlags", VALUEFUNC(_wrap_TerrainGlobalOptions_getQueryFlags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "addQueryFlags", VALUEFUNC(_wrap_TerrainGlobalOptions_addQueryFlags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "removeQueryFlags", VALUEFUNC(_wrap_TerrainGlobalOptions_removeQueryFlags), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getUseRayBoxDistanceCalculation", VALUEFUNC(_wrap_TerrainGlobalOptions_getUseRayBoxDistanceCalculation), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setUseRayBoxDistanceCalculation", VALUEFUNC(_wrap_TerrainGlobalOptions_setUseRayBoxDistanceCalculation), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getDefaultMaterialGenerator", VALUEFUNC(_wrap_TerrainGlobalOptions_getDefaultMaterialGenerator), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setDefaultMaterialGenerator", VALUEFUNC(_wrap_TerrainGlobalOptions_setDefaultMaterialGenerator), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getLayerBlendMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_getLayerBlendMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setLayerBlendMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_setLayerBlendMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getDefaultLayerTextureWorldSize", VALUEFUNC(_wrap_TerrainGlobalOptions_getDefaultLayerTextureWorldSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setDefaultLayerTextureWorldSize", VALUEFUNC(_wrap_TerrainGlobalOptions_setDefaultLayerTextureWorldSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getDefaultGlobalColourMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_getDefaultGlobalColourMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setDefaultGlobalColourMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_setDefaultGlobalColourMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getLightMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_getLightMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setLightMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_setLightMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getCompositeMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_getCompositeMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setCompositeMapSize", VALUEFUNC(_wrap_TerrainGlobalOptions_setCompositeMapSize), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setDefaultResourceGroup", VALUEFUNC(_wrap_TerrainGlobalOptions_setDefaultResourceGroup), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getDefaultResourceGroup", VALUEFUNC(_wrap_TerrainGlobalOptions_getDefaultResourceGroup), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "getUseVertexCompressionWhenAvailable", VALUEFUNC(_wrap_TerrainGlobalOptions_getUseVertexCompressionWhenAvailable), -1);
  rb_define_method(SwigClassTerrainGlobalOptions.klass, "setUseVertexCompressionWhenAvailable", VALUEFUNC(_wrap_TerrainGlobalOptions_setUseVertexCompressionWhenAvailable), -1);
  rb_define_singleton_method(SwigClassTerrainGlobalOptions.klass, "getSingleton", VALUEFUNC(_wrap_TerrainGlobalOptions_getSingleton), -1);
  rb_define_singleton_method(SwigClassTerrainGlobalOptions.klass, "getSingletonPtr", VALUEFUNC(_wrap_TerrainGlobalOptions_getSingletonPtr), -1);
  SwigClassTerrainGlobalOptions.mark = 0;
  SwigClassTerrainGlobalOptions.destroy = (void (*)(void *)) free_Ogre_TerrainGlobalOptions;
  SwigClassTerrainGlobalOptions.trackObjects = 0;
}